1/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
2
3Licensed under the Apache License, Version 2.0 (the "License");
4you may not use this file except in compliance with the License.
5You may obtain a copy of the License at
6
7 http://www.apache.org/licenses/LICENSE-2.0
8
9Unless required by applicable law or agreed to in writing, software
10distributed under the License is distributed on an "AS IS" BASIS,
11WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12See the License for the specific language governing permissions and
13limitations under the License.
14==============================================================================*/
15// automatically generated by the FlatBuffers compiler, do not modify
16
17
18#ifndef FLATBUFFERS_GENERATED_SCHEMA_TFLITE_H_
19#define FLATBUFFERS_GENERATED_SCHEMA_TFLITE_H_
20
21#include "flatbuffers/flatbuffers.h"
22
23namespace tflite {
24
25struct CustomQuantization;
26struct CustomQuantizationT;
27
28struct QuantizationParameters;
29struct QuantizationParametersT;
30
31struct Int32Vector;
32struct Int32VectorT;
33
34struct Uint16Vector;
35struct Uint16VectorT;
36
37struct Uint8Vector;
38struct Uint8VectorT;
39
40struct DimensionMetadata;
41struct DimensionMetadataT;
42
43struct SparsityParameters;
44struct SparsityParametersT;
45
46struct Tensor;
47struct TensorT;
48
49struct Conv2DOptions;
50struct Conv2DOptionsT;
51
52struct Conv3DOptions;
53struct Conv3DOptionsT;
54
55struct Pool2DOptions;
56struct Pool2DOptionsT;
57
58struct DepthwiseConv2DOptions;
59struct DepthwiseConv2DOptionsT;
60
61struct ConcatEmbeddingsOptions;
62struct ConcatEmbeddingsOptionsT;
63
64struct LSHProjectionOptions;
65struct LSHProjectionOptionsT;
66
67struct SVDFOptions;
68struct SVDFOptionsT;
69
70struct RNNOptions;
71struct RNNOptionsT;
72
73struct SequenceRNNOptions;
74struct SequenceRNNOptionsT;
75
76struct BidirectionalSequenceRNNOptions;
77struct BidirectionalSequenceRNNOptionsT;
78
79struct FullyConnectedOptions;
80struct FullyConnectedOptionsT;
81
82struct SoftmaxOptions;
83struct SoftmaxOptionsT;
84
85struct ConcatenationOptions;
86struct ConcatenationOptionsT;
87
88struct AddOptions;
89struct AddOptionsT;
90
91struct MulOptions;
92struct MulOptionsT;
93
94struct L2NormOptions;
95struct L2NormOptionsT;
96
97struct LocalResponseNormalizationOptions;
98struct LocalResponseNormalizationOptionsT;
99
100struct LSTMOptions;
101struct LSTMOptionsT;
102
103struct UnidirectionalSequenceLSTMOptions;
104struct UnidirectionalSequenceLSTMOptionsT;
105
106struct BidirectionalSequenceLSTMOptions;
107struct BidirectionalSequenceLSTMOptionsT;
108
109struct ResizeBilinearOptions;
110struct ResizeBilinearOptionsT;
111
112struct ResizeNearestNeighborOptions;
113struct ResizeNearestNeighborOptionsT;
114
115struct CallOptions;
116struct CallOptionsT;
117
118struct PadOptions;
119struct PadOptionsT;
120
121struct PadV2Options;
122struct PadV2OptionsT;
123
124struct ReshapeOptions;
125struct ReshapeOptionsT;
126
127struct SpaceToBatchNDOptions;
128struct SpaceToBatchNDOptionsT;
129
130struct BatchToSpaceNDOptions;
131struct BatchToSpaceNDOptionsT;
132
133struct SkipGramOptions;
134struct SkipGramOptionsT;
135
136struct SpaceToDepthOptions;
137struct SpaceToDepthOptionsT;
138
139struct DepthToSpaceOptions;
140struct DepthToSpaceOptionsT;
141
142struct SubOptions;
143struct SubOptionsT;
144
145struct DivOptions;
146struct DivOptionsT;
147
148struct TopKV2Options;
149struct TopKV2OptionsT;
150
151struct EmbeddingLookupSparseOptions;
152struct EmbeddingLookupSparseOptionsT;
153
154struct GatherOptions;
155struct GatherOptionsT;
156
157struct TransposeOptions;
158struct TransposeOptionsT;
159
160struct ExpOptions;
161struct ExpOptionsT;
162
163struct CosOptions;
164struct CosOptionsT;
165
166struct ReducerOptions;
167struct ReducerOptionsT;
168
169struct SqueezeOptions;
170struct SqueezeOptionsT;
171
172struct SplitOptions;
173struct SplitOptionsT;
174
175struct SplitVOptions;
176struct SplitVOptionsT;
177
178struct StridedSliceOptions;
179struct StridedSliceOptionsT;
180
181struct LogSoftmaxOptions;
182struct LogSoftmaxOptionsT;
183
184struct CastOptions;
185struct CastOptionsT;
186
187struct DequantizeOptions;
188struct DequantizeOptionsT;
189
190struct MaximumMinimumOptions;
191struct MaximumMinimumOptionsT;
192
193struct TileOptions;
194struct TileOptionsT;
195
196struct ArgMaxOptions;
197struct ArgMaxOptionsT;
198
199struct ArgMinOptions;
200struct ArgMinOptionsT;
201
202struct GreaterOptions;
203struct GreaterOptionsT;
204
205struct GreaterEqualOptions;
206struct GreaterEqualOptionsT;
207
208struct LessOptions;
209struct LessOptionsT;
210
211struct LessEqualOptions;
212struct LessEqualOptionsT;
213
214struct NegOptions;
215struct NegOptionsT;
216
217struct SelectOptions;
218struct SelectOptionsT;
219
220struct SliceOptions;
221struct SliceOptionsT;
222
223struct TransposeConvOptions;
224struct TransposeConvOptionsT;
225
226struct ExpandDimsOptions;
227struct ExpandDimsOptionsT;
228
229struct SparseToDenseOptions;
230struct SparseToDenseOptionsT;
231
232struct EqualOptions;
233struct EqualOptionsT;
234
235struct NotEqualOptions;
236struct NotEqualOptionsT;
237
238struct ShapeOptions;
239struct ShapeOptionsT;
240
241struct RankOptions;
242struct RankOptionsT;
243
244struct PowOptions;
245struct PowOptionsT;
246
247struct FakeQuantOptions;
248struct FakeQuantOptionsT;
249
250struct PackOptions;
251struct PackOptionsT;
252
253struct LogicalOrOptions;
254struct LogicalOrOptionsT;
255
256struct OneHotOptions;
257struct OneHotOptionsT;
258
259struct AbsOptions;
260struct AbsOptionsT;
261
262struct HardSwishOptions;
263struct HardSwishOptionsT;
264
265struct LogicalAndOptions;
266struct LogicalAndOptionsT;
267
268struct LogicalNotOptions;
269struct LogicalNotOptionsT;
270
271struct UnpackOptions;
272struct UnpackOptionsT;
273
274struct FloorDivOptions;
275struct FloorDivOptionsT;
276
277struct SquareOptions;
278struct SquareOptionsT;
279
280struct ZerosLikeOptions;
281struct ZerosLikeOptionsT;
282
283struct FillOptions;
284struct FillOptionsT;
285
286struct FloorModOptions;
287struct FloorModOptionsT;
288
289struct RangeOptions;
290struct RangeOptionsT;
291
292struct LeakyReluOptions;
293struct LeakyReluOptionsT;
294
295struct SquaredDifferenceOptions;
296struct SquaredDifferenceOptionsT;
297
298struct MirrorPadOptions;
299struct MirrorPadOptionsT;
300
301struct UniqueOptions;
302struct UniqueOptionsT;
303
304struct ReverseV2Options;
305struct ReverseV2OptionsT;
306
307struct AddNOptions;
308struct AddNOptionsT;
309
310struct GatherNdOptions;
311struct GatherNdOptionsT;
312
313struct WhereOptions;
314struct WhereOptionsT;
315
316struct ReverseSequenceOptions;
317struct ReverseSequenceOptionsT;
318
319struct MatrixDiagOptions;
320struct MatrixDiagOptionsT;
321
322struct QuantizeOptions;
323struct QuantizeOptionsT;
324
325struct MatrixSetDiagOptions;
326struct MatrixSetDiagOptionsT;
327
328struct IfOptions;
329struct IfOptionsT;
330
331struct CallOnceOptions;
332struct CallOnceOptionsT;
333
334struct WhileOptions;
335struct WhileOptionsT;
336
337struct NonMaxSuppressionV4Options;
338struct NonMaxSuppressionV4OptionsT;
339
340struct NonMaxSuppressionV5Options;
341struct NonMaxSuppressionV5OptionsT;
342
343struct ScatterNdOptions;
344struct ScatterNdOptionsT;
345
346struct SelectV2Options;
347struct SelectV2OptionsT;
348
349struct DensifyOptions;
350struct DensifyOptionsT;
351
352struct SegmentSumOptions;
353struct SegmentSumOptionsT;
354
355struct BatchMatMulOptions;
356struct BatchMatMulOptionsT;
357
358struct CumsumOptions;
359struct CumsumOptionsT;
360
361struct BroadcastToOptions;
362struct BroadcastToOptionsT;
363
364struct Rfft2dOptions;
365struct Rfft2dOptionsT;
366
367struct HashtableOptions;
368struct HashtableOptionsT;
369
370struct HashtableFindOptions;
371struct HashtableFindOptionsT;
372
373struct HashtableImportOptions;
374struct HashtableImportOptionsT;
375
376struct HashtableSizeOptions;
377struct HashtableSizeOptionsT;
378
379struct OperatorCode;
380struct OperatorCodeT;
381
382struct Operator;
383struct OperatorT;
384
385struct SubGraph;
386struct SubGraphT;
387
388struct Buffer;
389struct BufferT;
390
391struct Metadata;
392struct MetadataT;
393
394struct TensorMap;
395struct TensorMapT;
396
397struct SignatureDef;
398struct SignatureDefT;
399
400struct Model;
401struct ModelT;
402
403enum TensorType {
404 TensorType_FLOAT32 = 0,
405 TensorType_FLOAT16 = 1,
406 TensorType_INT32 = 2,
407 TensorType_UINT8 = 3,
408 TensorType_INT64 = 4,
409 TensorType_STRING = 5,
410 TensorType_BOOL = 6,
411 TensorType_INT16 = 7,
412 TensorType_COMPLEX64 = 8,
413 TensorType_INT8 = 9,
414 TensorType_FLOAT64 = 10,
415 TensorType_COMPLEX128 = 11,
416 TensorType_UINT64 = 12,
417 TensorType_RESOURCE = 13,
418 TensorType_VARIANT = 14,
419 TensorType_UINT32 = 15,
420 TensorType_MIN = TensorType_FLOAT32,
421 TensorType_MAX = TensorType_UINT32
422};
423
424inline const TensorType (&EnumValuesTensorType())[16] {
425 static const TensorType values[] = {
426 TensorType_FLOAT32,
427 TensorType_FLOAT16,
428 TensorType_INT32,
429 TensorType_UINT8,
430 TensorType_INT64,
431 TensorType_STRING,
432 TensorType_BOOL,
433 TensorType_INT16,
434 TensorType_COMPLEX64,
435 TensorType_INT8,
436 TensorType_FLOAT64,
437 TensorType_COMPLEX128,
438 TensorType_UINT64,
439 TensorType_RESOURCE,
440 TensorType_VARIANT,
441 TensorType_UINT32
442 };
443 return values;
444}
445
446inline const char * const *EnumNamesTensorType() {
447 static const char * const names[17] = {
448 "FLOAT32",
449 "FLOAT16",
450 "INT32",
451 "UINT8",
452 "INT64",
453 "STRING",
454 "BOOL",
455 "INT16",
456 "COMPLEX64",
457 "INT8",
458 "FLOAT64",
459 "COMPLEX128",
460 "UINT64",
461 "RESOURCE",
462 "VARIANT",
463 "UINT32",
464 nullptr
465 };
466 return names;
467}
468
469inline const char *EnumNameTensorType(TensorType e) {
470 if (flatbuffers::IsOutRange(e, TensorType_FLOAT32, TensorType_UINT32)) return "";
471 const size_t index = static_cast<size_t>(e);
472 return EnumNamesTensorType()[index];
473}
474
475enum QuantizationDetails {
476 QuantizationDetails_NONE = 0,
477 QuantizationDetails_CustomQuantization = 1,
478 QuantizationDetails_MIN = QuantizationDetails_NONE,
479 QuantizationDetails_MAX = QuantizationDetails_CustomQuantization
480};
481
482inline const QuantizationDetails (&EnumValuesQuantizationDetails())[2] {
483 static const QuantizationDetails values[] = {
484 QuantizationDetails_NONE,
485 QuantizationDetails_CustomQuantization
486 };
487 return values;
488}
489
490inline const char * const *EnumNamesQuantizationDetails() {
491 static const char * const names[3] = {
492 "NONE",
493 "CustomQuantization",
494 nullptr
495 };
496 return names;
497}
498
499inline const char *EnumNameQuantizationDetails(QuantizationDetails e) {
500 if (flatbuffers::IsOutRange(e, QuantizationDetails_NONE, QuantizationDetails_CustomQuantization)) return "";
501 const size_t index = static_cast<size_t>(e);
502 return EnumNamesQuantizationDetails()[index];
503}
504
505template<typename T> struct QuantizationDetailsTraits {
506 static const QuantizationDetails enum_value = QuantizationDetails_NONE;
507};
508
509template<> struct QuantizationDetailsTraits<tflite::CustomQuantization> {
510 static const QuantizationDetails enum_value = QuantizationDetails_CustomQuantization;
511};
512
513struct QuantizationDetailsUnion {
514 QuantizationDetails type;
515 void *value;
516
517 QuantizationDetailsUnion() : type(QuantizationDetails_NONE), value(nullptr) {}
518 QuantizationDetailsUnion(QuantizationDetailsUnion&& u) FLATBUFFERS_NOEXCEPT :
519 type(QuantizationDetails_NONE), value(nullptr)
520 { std::swap(type, u.type); std::swap(value, u.value); }
521 QuantizationDetailsUnion(const QuantizationDetailsUnion &) FLATBUFFERS_NOEXCEPT;
522 QuantizationDetailsUnion &operator=(const QuantizationDetailsUnion &u) FLATBUFFERS_NOEXCEPT
523 { QuantizationDetailsUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
524 QuantizationDetailsUnion &operator=(QuantizationDetailsUnion &&u) FLATBUFFERS_NOEXCEPT
525 { std::swap(type, u.type); std::swap(value, u.value); return *this; }
526 ~QuantizationDetailsUnion() { Reset(); }
527
528 void Reset();
529
530#ifndef FLATBUFFERS_CPP98_STL
531 template <typename T>
532 void Set(T&& val) {
533 using RT = typename std::remove_reference<T>::type;
534 Reset();
535 type = QuantizationDetailsTraits<typename RT::TableType>::enum_value;
536 if (type != QuantizationDetails_NONE) {
537 value = new RT(std::forward<T>(val));
538 }
539 }
540#endif // FLATBUFFERS_CPP98_STL
541
542 static void *UnPack(const void *obj, QuantizationDetails type, const flatbuffers::resolver_function_t *resolver);
543 flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
544
545 tflite::CustomQuantizationT *AsCustomQuantization() {
546 return type == QuantizationDetails_CustomQuantization ?
547 reinterpret_cast<tflite::CustomQuantizationT *>(value) : nullptr;
548 }
549 const tflite::CustomQuantizationT *AsCustomQuantization() const {
550 return type == QuantizationDetails_CustomQuantization ?
551 reinterpret_cast<const tflite::CustomQuantizationT *>(value) : nullptr;
552 }
553};
554
555bool VerifyQuantizationDetails(flatbuffers::Verifier &verifier, const void *obj, QuantizationDetails type);
556bool VerifyQuantizationDetailsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
557
558enum DimensionType {
559 DimensionType_DENSE = 0,
560 DimensionType_SPARSE_CSR = 1,
561 DimensionType_MIN = DimensionType_DENSE,
562 DimensionType_MAX = DimensionType_SPARSE_CSR
563};
564
565inline const DimensionType (&EnumValuesDimensionType())[2] {
566 static const DimensionType values[] = {
567 DimensionType_DENSE,
568 DimensionType_SPARSE_CSR
569 };
570 return values;
571}
572
573inline const char * const *EnumNamesDimensionType() {
574 static const char * const names[3] = {
575 "DENSE",
576 "SPARSE_CSR",
577 nullptr
578 };
579 return names;
580}
581
582inline const char *EnumNameDimensionType(DimensionType e) {
583 if (flatbuffers::IsOutRange(e, DimensionType_DENSE, DimensionType_SPARSE_CSR)) return "";
584 const size_t index = static_cast<size_t>(e);
585 return EnumNamesDimensionType()[index];
586}
587
588enum SparseIndexVector {
589 SparseIndexVector_NONE = 0,
590 SparseIndexVector_Int32Vector = 1,
591 SparseIndexVector_Uint16Vector = 2,
592 SparseIndexVector_Uint8Vector = 3,
593 SparseIndexVector_MIN = SparseIndexVector_NONE,
594 SparseIndexVector_MAX = SparseIndexVector_Uint8Vector
595};
596
597inline const SparseIndexVector (&EnumValuesSparseIndexVector())[4] {
598 static const SparseIndexVector values[] = {
599 SparseIndexVector_NONE,
600 SparseIndexVector_Int32Vector,
601 SparseIndexVector_Uint16Vector,
602 SparseIndexVector_Uint8Vector
603 };
604 return values;
605}
606
607inline const char * const *EnumNamesSparseIndexVector() {
608 static const char * const names[5] = {
609 "NONE",
610 "Int32Vector",
611 "Uint16Vector",
612 "Uint8Vector",
613 nullptr
614 };
615 return names;
616}
617
618inline const char *EnumNameSparseIndexVector(SparseIndexVector e) {
619 if (flatbuffers::IsOutRange(e, SparseIndexVector_NONE, SparseIndexVector_Uint8Vector)) return "";
620 const size_t index = static_cast<size_t>(e);
621 return EnumNamesSparseIndexVector()[index];
622}
623
624template<typename T> struct SparseIndexVectorTraits {
625 static const SparseIndexVector enum_value = SparseIndexVector_NONE;
626};
627
628template<> struct SparseIndexVectorTraits<tflite::Int32Vector> {
629 static const SparseIndexVector enum_value = SparseIndexVector_Int32Vector;
630};
631
632template<> struct SparseIndexVectorTraits<tflite::Uint16Vector> {
633 static const SparseIndexVector enum_value = SparseIndexVector_Uint16Vector;
634};
635
636template<> struct SparseIndexVectorTraits<tflite::Uint8Vector> {
637 static const SparseIndexVector enum_value = SparseIndexVector_Uint8Vector;
638};
639
640struct SparseIndexVectorUnion {
641 SparseIndexVector type;
642 void *value;
643
644 SparseIndexVectorUnion() : type(SparseIndexVector_NONE), value(nullptr) {}
645 SparseIndexVectorUnion(SparseIndexVectorUnion&& u) FLATBUFFERS_NOEXCEPT :
646 type(SparseIndexVector_NONE), value(nullptr)
647 { std::swap(type, u.type); std::swap(value, u.value); }
648 SparseIndexVectorUnion(const SparseIndexVectorUnion &) FLATBUFFERS_NOEXCEPT;
649 SparseIndexVectorUnion &operator=(const SparseIndexVectorUnion &u) FLATBUFFERS_NOEXCEPT
650 { SparseIndexVectorUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
651 SparseIndexVectorUnion &operator=(SparseIndexVectorUnion &&u) FLATBUFFERS_NOEXCEPT
652 { std::swap(type, u.type); std::swap(value, u.value); return *this; }
653 ~SparseIndexVectorUnion() { Reset(); }
654
655 void Reset();
656
657#ifndef FLATBUFFERS_CPP98_STL
658 template <typename T>
659 void Set(T&& val) {
660 using RT = typename std::remove_reference<T>::type;
661 Reset();
662 type = SparseIndexVectorTraits<typename RT::TableType>::enum_value;
663 if (type != SparseIndexVector_NONE) {
664 value = new RT(std::forward<T>(val));
665 }
666 }
667#endif // FLATBUFFERS_CPP98_STL
668
669 static void *UnPack(const void *obj, SparseIndexVector type, const flatbuffers::resolver_function_t *resolver);
670 flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
671
672 tflite::Int32VectorT *AsInt32Vector() {
673 return type == SparseIndexVector_Int32Vector ?
674 reinterpret_cast<tflite::Int32VectorT *>(value) : nullptr;
675 }
676 const tflite::Int32VectorT *AsInt32Vector() const {
677 return type == SparseIndexVector_Int32Vector ?
678 reinterpret_cast<const tflite::Int32VectorT *>(value) : nullptr;
679 }
680 tflite::Uint16VectorT *AsUint16Vector() {
681 return type == SparseIndexVector_Uint16Vector ?
682 reinterpret_cast<tflite::Uint16VectorT *>(value) : nullptr;
683 }
684 const tflite::Uint16VectorT *AsUint16Vector() const {
685 return type == SparseIndexVector_Uint16Vector ?
686 reinterpret_cast<const tflite::Uint16VectorT *>(value) : nullptr;
687 }
688 tflite::Uint8VectorT *AsUint8Vector() {
689 return type == SparseIndexVector_Uint8Vector ?
690 reinterpret_cast<tflite::Uint8VectorT *>(value) : nullptr;
691 }
692 const tflite::Uint8VectorT *AsUint8Vector() const {
693 return type == SparseIndexVector_Uint8Vector ?
694 reinterpret_cast<const tflite::Uint8VectorT *>(value) : nullptr;
695 }
696};
697
698bool VerifySparseIndexVector(flatbuffers::Verifier &verifier, const void *obj, SparseIndexVector type);
699bool VerifySparseIndexVectorVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
700
701enum BuiltinOperator {
702 BuiltinOperator_ADD = 0,
703 BuiltinOperator_AVERAGE_POOL_2D = 1,
704 BuiltinOperator_CONCATENATION = 2,
705 BuiltinOperator_CONV_2D = 3,
706 BuiltinOperator_DEPTHWISE_CONV_2D = 4,
707 BuiltinOperator_DEPTH_TO_SPACE = 5,
708 BuiltinOperator_DEQUANTIZE = 6,
709 BuiltinOperator_EMBEDDING_LOOKUP = 7,
710 BuiltinOperator_FLOOR = 8,
711 BuiltinOperator_FULLY_CONNECTED = 9,
712 BuiltinOperator_HASHTABLE_LOOKUP = 10,
713 BuiltinOperator_L2_NORMALIZATION = 11,
714 BuiltinOperator_L2_POOL_2D = 12,
715 BuiltinOperator_LOCAL_RESPONSE_NORMALIZATION = 13,
716 BuiltinOperator_LOGISTIC = 14,
717 BuiltinOperator_LSH_PROJECTION = 15,
718 BuiltinOperator_LSTM = 16,
719 BuiltinOperator_MAX_POOL_2D = 17,
720 BuiltinOperator_MUL = 18,
721 BuiltinOperator_RELU = 19,
722 BuiltinOperator_RELU_N1_TO_1 = 20,
723 BuiltinOperator_RELU6 = 21,
724 BuiltinOperator_RESHAPE = 22,
725 BuiltinOperator_RESIZE_BILINEAR = 23,
726 BuiltinOperator_RNN = 24,
727 BuiltinOperator_SOFTMAX = 25,
728 BuiltinOperator_SPACE_TO_DEPTH = 26,
729 BuiltinOperator_SVDF = 27,
730 BuiltinOperator_TANH = 28,
731 BuiltinOperator_CONCAT_EMBEDDINGS = 29,
732 BuiltinOperator_SKIP_GRAM = 30,
733 BuiltinOperator_CALL = 31,
734 BuiltinOperator_CUSTOM = 32,
735 BuiltinOperator_EMBEDDING_LOOKUP_SPARSE = 33,
736 BuiltinOperator_PAD = 34,
737 BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_RNN = 35,
738 BuiltinOperator_GATHER = 36,
739 BuiltinOperator_BATCH_TO_SPACE_ND = 37,
740 BuiltinOperator_SPACE_TO_BATCH_ND = 38,
741 BuiltinOperator_TRANSPOSE = 39,
742 BuiltinOperator_MEAN = 40,
743 BuiltinOperator_SUB = 41,
744 BuiltinOperator_DIV = 42,
745 BuiltinOperator_SQUEEZE = 43,
746 BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_LSTM = 44,
747 BuiltinOperator_STRIDED_SLICE = 45,
748 BuiltinOperator_BIDIRECTIONAL_SEQUENCE_RNN = 46,
749 BuiltinOperator_EXP = 47,
750 BuiltinOperator_TOPK_V2 = 48,
751 BuiltinOperator_SPLIT = 49,
752 BuiltinOperator_LOG_SOFTMAX = 50,
753 BuiltinOperator_DELEGATE = 51,
754 BuiltinOperator_BIDIRECTIONAL_SEQUENCE_LSTM = 52,
755 BuiltinOperator_CAST = 53,
756 BuiltinOperator_PRELU = 54,
757 BuiltinOperator_MAXIMUM = 55,
758 BuiltinOperator_ARG_MAX = 56,
759 BuiltinOperator_MINIMUM = 57,
760 BuiltinOperator_LESS = 58,
761 BuiltinOperator_NEG = 59,
762 BuiltinOperator_PADV2 = 60,
763 BuiltinOperator_GREATER = 61,
764 BuiltinOperator_GREATER_EQUAL = 62,
765 BuiltinOperator_LESS_EQUAL = 63,
766 BuiltinOperator_SELECT = 64,
767 BuiltinOperator_SLICE = 65,
768 BuiltinOperator_SIN = 66,
769 BuiltinOperator_TRANSPOSE_CONV = 67,
770 BuiltinOperator_SPARSE_TO_DENSE = 68,
771 BuiltinOperator_TILE = 69,
772 BuiltinOperator_EXPAND_DIMS = 70,
773 BuiltinOperator_EQUAL = 71,
774 BuiltinOperator_NOT_EQUAL = 72,
775 BuiltinOperator_LOG = 73,
776 BuiltinOperator_SUM = 74,
777 BuiltinOperator_SQRT = 75,
778 BuiltinOperator_RSQRT = 76,
779 BuiltinOperator_SHAPE = 77,
780 BuiltinOperator_POW = 78,
781 BuiltinOperator_ARG_MIN = 79,
782 BuiltinOperator_FAKE_QUANT = 80,
783 BuiltinOperator_REDUCE_PROD = 81,
784 BuiltinOperator_REDUCE_MAX = 82,
785 BuiltinOperator_PACK = 83,
786 BuiltinOperator_LOGICAL_OR = 84,
787 BuiltinOperator_ONE_HOT = 85,
788 BuiltinOperator_LOGICAL_AND = 86,
789 BuiltinOperator_LOGICAL_NOT = 87,
790 BuiltinOperator_UNPACK = 88,
791 BuiltinOperator_REDUCE_MIN = 89,
792 BuiltinOperator_FLOOR_DIV = 90,
793 BuiltinOperator_REDUCE_ANY = 91,
794 BuiltinOperator_SQUARE = 92,
795 BuiltinOperator_ZEROS_LIKE = 93,
796 BuiltinOperator_FILL = 94,
797 BuiltinOperator_FLOOR_MOD = 95,
798 BuiltinOperator_RANGE = 96,
799 BuiltinOperator_RESIZE_NEAREST_NEIGHBOR = 97,
800 BuiltinOperator_LEAKY_RELU = 98,
801 BuiltinOperator_SQUARED_DIFFERENCE = 99,
802 BuiltinOperator_MIRROR_PAD = 100,
803 BuiltinOperator_ABS = 101,
804 BuiltinOperator_SPLIT_V = 102,
805 BuiltinOperator_UNIQUE = 103,
806 BuiltinOperator_CEIL = 104,
807 BuiltinOperator_REVERSE_V2 = 105,
808 BuiltinOperator_ADD_N = 106,
809 BuiltinOperator_GATHER_ND = 107,
810 BuiltinOperator_COS = 108,
811 BuiltinOperator_WHERE = 109,
812 BuiltinOperator_RANK = 110,
813 BuiltinOperator_ELU = 111,
814 BuiltinOperator_REVERSE_SEQUENCE = 112,
815 BuiltinOperator_MATRIX_DIAG = 113,
816 BuiltinOperator_QUANTIZE = 114,
817 BuiltinOperator_MATRIX_SET_DIAG = 115,
818 BuiltinOperator_ROUND = 116,
819 BuiltinOperator_HARD_SWISH = 117,
820 BuiltinOperator_IF = 118,
821 BuiltinOperator_WHILE = 119,
822 BuiltinOperator_NON_MAX_SUPPRESSION_V4 = 120,
823 BuiltinOperator_NON_MAX_SUPPRESSION_V5 = 121,
824 BuiltinOperator_SCATTER_ND = 122,
825 BuiltinOperator_SELECT_V2 = 123,
826 BuiltinOperator_DENSIFY = 124,
827 BuiltinOperator_SEGMENT_SUM = 125,
828 BuiltinOperator_BATCH_MATMUL = 126,
829 BuiltinOperator_PLACEHOLDER_FOR_GREATER_OP_CODES = 127,
830 BuiltinOperator_CUMSUM = 128,
831 BuiltinOperator_CALL_ONCE = 129,
832 BuiltinOperator_BROADCAST_TO = 130,
833 BuiltinOperator_RFFT2D = 131,
834 BuiltinOperator_CONV_3D = 132,
835 BuiltinOperator_IMAG = 133,
836 BuiltinOperator_REAL = 134,
837 BuiltinOperator_COMPLEX_ABS = 135,
838 BuiltinOperator_HASHTABLE = 136,
839 BuiltinOperator_HASHTABLE_FIND = 137,
840 BuiltinOperator_HASHTABLE_IMPORT = 138,
841 BuiltinOperator_HASHTABLE_SIZE = 139,
842 BuiltinOperator_MIN = BuiltinOperator_ADD,
843 BuiltinOperator_MAX = BuiltinOperator_HASHTABLE_SIZE
844};
845
846inline const BuiltinOperator (&EnumValuesBuiltinOperator())[140] {
847 static const BuiltinOperator values[] = {
848 BuiltinOperator_ADD,
849 BuiltinOperator_AVERAGE_POOL_2D,
850 BuiltinOperator_CONCATENATION,
851 BuiltinOperator_CONV_2D,
852 BuiltinOperator_DEPTHWISE_CONV_2D,
853 BuiltinOperator_DEPTH_TO_SPACE,
854 BuiltinOperator_DEQUANTIZE,
855 BuiltinOperator_EMBEDDING_LOOKUP,
856 BuiltinOperator_FLOOR,
857 BuiltinOperator_FULLY_CONNECTED,
858 BuiltinOperator_HASHTABLE_LOOKUP,
859 BuiltinOperator_L2_NORMALIZATION,
860 BuiltinOperator_L2_POOL_2D,
861 BuiltinOperator_LOCAL_RESPONSE_NORMALIZATION,
862 BuiltinOperator_LOGISTIC,
863 BuiltinOperator_LSH_PROJECTION,
864 BuiltinOperator_LSTM,
865 BuiltinOperator_MAX_POOL_2D,
866 BuiltinOperator_MUL,
867 BuiltinOperator_RELU,
868 BuiltinOperator_RELU_N1_TO_1,
869 BuiltinOperator_RELU6,
870 BuiltinOperator_RESHAPE,
871 BuiltinOperator_RESIZE_BILINEAR,
872 BuiltinOperator_RNN,
873 BuiltinOperator_SOFTMAX,
874 BuiltinOperator_SPACE_TO_DEPTH,
875 BuiltinOperator_SVDF,
876 BuiltinOperator_TANH,
877 BuiltinOperator_CONCAT_EMBEDDINGS,
878 BuiltinOperator_SKIP_GRAM,
879 BuiltinOperator_CALL,
880 BuiltinOperator_CUSTOM,
881 BuiltinOperator_EMBEDDING_LOOKUP_SPARSE,
882 BuiltinOperator_PAD,
883 BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_RNN,
884 BuiltinOperator_GATHER,
885 BuiltinOperator_BATCH_TO_SPACE_ND,
886 BuiltinOperator_SPACE_TO_BATCH_ND,
887 BuiltinOperator_TRANSPOSE,
888 BuiltinOperator_MEAN,
889 BuiltinOperator_SUB,
890 BuiltinOperator_DIV,
891 BuiltinOperator_SQUEEZE,
892 BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_LSTM,
893 BuiltinOperator_STRIDED_SLICE,
894 BuiltinOperator_BIDIRECTIONAL_SEQUENCE_RNN,
895 BuiltinOperator_EXP,
896 BuiltinOperator_TOPK_V2,
897 BuiltinOperator_SPLIT,
898 BuiltinOperator_LOG_SOFTMAX,
899 BuiltinOperator_DELEGATE,
900 BuiltinOperator_BIDIRECTIONAL_SEQUENCE_LSTM,
901 BuiltinOperator_CAST,
902 BuiltinOperator_PRELU,
903 BuiltinOperator_MAXIMUM,
904 BuiltinOperator_ARG_MAX,
905 BuiltinOperator_MINIMUM,
906 BuiltinOperator_LESS,
907 BuiltinOperator_NEG,
908 BuiltinOperator_PADV2,
909 BuiltinOperator_GREATER,
910 BuiltinOperator_GREATER_EQUAL,
911 BuiltinOperator_LESS_EQUAL,
912 BuiltinOperator_SELECT,
913 BuiltinOperator_SLICE,
914 BuiltinOperator_SIN,
915 BuiltinOperator_TRANSPOSE_CONV,
916 BuiltinOperator_SPARSE_TO_DENSE,
917 BuiltinOperator_TILE,
918 BuiltinOperator_EXPAND_DIMS,
919 BuiltinOperator_EQUAL,
920 BuiltinOperator_NOT_EQUAL,
921 BuiltinOperator_LOG,
922 BuiltinOperator_SUM,
923 BuiltinOperator_SQRT,
924 BuiltinOperator_RSQRT,
925 BuiltinOperator_SHAPE,
926 BuiltinOperator_POW,
927 BuiltinOperator_ARG_MIN,
928 BuiltinOperator_FAKE_QUANT,
929 BuiltinOperator_REDUCE_PROD,
930 BuiltinOperator_REDUCE_MAX,
931 BuiltinOperator_PACK,
932 BuiltinOperator_LOGICAL_OR,
933 BuiltinOperator_ONE_HOT,
934 BuiltinOperator_LOGICAL_AND,
935 BuiltinOperator_LOGICAL_NOT,
936 BuiltinOperator_UNPACK,
937 BuiltinOperator_REDUCE_MIN,
938 BuiltinOperator_FLOOR_DIV,
939 BuiltinOperator_REDUCE_ANY,
940 BuiltinOperator_SQUARE,
941 BuiltinOperator_ZEROS_LIKE,
942 BuiltinOperator_FILL,
943 BuiltinOperator_FLOOR_MOD,
944 BuiltinOperator_RANGE,
945 BuiltinOperator_RESIZE_NEAREST_NEIGHBOR,
946 BuiltinOperator_LEAKY_RELU,
947 BuiltinOperator_SQUARED_DIFFERENCE,
948 BuiltinOperator_MIRROR_PAD,
949 BuiltinOperator_ABS,
950 BuiltinOperator_SPLIT_V,
951 BuiltinOperator_UNIQUE,
952 BuiltinOperator_CEIL,
953 BuiltinOperator_REVERSE_V2,
954 BuiltinOperator_ADD_N,
955 BuiltinOperator_GATHER_ND,
956 BuiltinOperator_COS,
957 BuiltinOperator_WHERE,
958 BuiltinOperator_RANK,
959 BuiltinOperator_ELU,
960 BuiltinOperator_REVERSE_SEQUENCE,
961 BuiltinOperator_MATRIX_DIAG,
962 BuiltinOperator_QUANTIZE,
963 BuiltinOperator_MATRIX_SET_DIAG,
964 BuiltinOperator_ROUND,
965 BuiltinOperator_HARD_SWISH,
966 BuiltinOperator_IF,
967 BuiltinOperator_WHILE,
968 BuiltinOperator_NON_MAX_SUPPRESSION_V4,
969 BuiltinOperator_NON_MAX_SUPPRESSION_V5,
970 BuiltinOperator_SCATTER_ND,
971 BuiltinOperator_SELECT_V2,
972 BuiltinOperator_DENSIFY,
973 BuiltinOperator_SEGMENT_SUM,
974 BuiltinOperator_BATCH_MATMUL,
975 BuiltinOperator_PLACEHOLDER_FOR_GREATER_OP_CODES,
976 BuiltinOperator_CUMSUM,
977 BuiltinOperator_CALL_ONCE,
978 BuiltinOperator_BROADCAST_TO,
979 BuiltinOperator_RFFT2D,
980 BuiltinOperator_CONV_3D,
981 BuiltinOperator_IMAG,
982 BuiltinOperator_REAL,
983 BuiltinOperator_COMPLEX_ABS,
984 BuiltinOperator_HASHTABLE,
985 BuiltinOperator_HASHTABLE_FIND,
986 BuiltinOperator_HASHTABLE_IMPORT,
987 BuiltinOperator_HASHTABLE_SIZE
988 };
989 return values;
990}
991
992inline const char * const *EnumNamesBuiltinOperator() {
993 static const char * const names[141] = {
994 "ADD",
995 "AVERAGE_POOL_2D",
996 "CONCATENATION",
997 "CONV_2D",
998 "DEPTHWISE_CONV_2D",
999 "DEPTH_TO_SPACE",
1000 "DEQUANTIZE",
1001 "EMBEDDING_LOOKUP",
1002 "FLOOR",
1003 "FULLY_CONNECTED",
1004 "HASHTABLE_LOOKUP",
1005 "L2_NORMALIZATION",
1006 "L2_POOL_2D",
1007 "LOCAL_RESPONSE_NORMALIZATION",
1008 "LOGISTIC",
1009 "LSH_PROJECTION",
1010 "LSTM",
1011 "MAX_POOL_2D",
1012 "MUL",
1013 "RELU",
1014 "RELU_N1_TO_1",
1015 "RELU6",
1016 "RESHAPE",
1017 "RESIZE_BILINEAR",
1018 "RNN",
1019 "SOFTMAX",
1020 "SPACE_TO_DEPTH",
1021 "SVDF",
1022 "TANH",
1023 "CONCAT_EMBEDDINGS",
1024 "SKIP_GRAM",
1025 "CALL",
1026 "CUSTOM",
1027 "EMBEDDING_LOOKUP_SPARSE",
1028 "PAD",
1029 "UNIDIRECTIONAL_SEQUENCE_RNN",
1030 "GATHER",
1031 "BATCH_TO_SPACE_ND",
1032 "SPACE_TO_BATCH_ND",
1033 "TRANSPOSE",
1034 "MEAN",
1035 "SUB",
1036 "DIV",
1037 "SQUEEZE",
1038 "UNIDIRECTIONAL_SEQUENCE_LSTM",
1039 "STRIDED_SLICE",
1040 "BIDIRECTIONAL_SEQUENCE_RNN",
1041 "EXP",
1042 "TOPK_V2",
1043 "SPLIT",
1044 "LOG_SOFTMAX",
1045 "DELEGATE",
1046 "BIDIRECTIONAL_SEQUENCE_LSTM",
1047 "CAST",
1048 "PRELU",
1049 "MAXIMUM",
1050 "ARG_MAX",
1051 "MINIMUM",
1052 "LESS",
1053 "NEG",
1054 "PADV2",
1055 "GREATER",
1056 "GREATER_EQUAL",
1057 "LESS_EQUAL",
1058 "SELECT",
1059 "SLICE",
1060 "SIN",
1061 "TRANSPOSE_CONV",
1062 "SPARSE_TO_DENSE",
1063 "TILE",
1064 "EXPAND_DIMS",
1065 "EQUAL",
1066 "NOT_EQUAL",
1067 "LOG",
1068 "SUM",
1069 "SQRT",
1070 "RSQRT",
1071 "SHAPE",
1072 "POW",
1073 "ARG_MIN",
1074 "FAKE_QUANT",
1075 "REDUCE_PROD",
1076 "REDUCE_MAX",
1077 "PACK",
1078 "LOGICAL_OR",
1079 "ONE_HOT",
1080 "LOGICAL_AND",
1081 "LOGICAL_NOT",
1082 "UNPACK",
1083 "REDUCE_MIN",
1084 "FLOOR_DIV",
1085 "REDUCE_ANY",
1086 "SQUARE",
1087 "ZEROS_LIKE",
1088 "FILL",
1089 "FLOOR_MOD",
1090 "RANGE",
1091 "RESIZE_NEAREST_NEIGHBOR",
1092 "LEAKY_RELU",
1093 "SQUARED_DIFFERENCE",
1094 "MIRROR_PAD",
1095 "ABS",
1096 "SPLIT_V",
1097 "UNIQUE",
1098 "CEIL",
1099 "REVERSE_V2",
1100 "ADD_N",
1101 "GATHER_ND",
1102 "COS",
1103 "WHERE",
1104 "RANK",
1105 "ELU",
1106 "REVERSE_SEQUENCE",
1107 "MATRIX_DIAG",
1108 "QUANTIZE",
1109 "MATRIX_SET_DIAG",
1110 "ROUND",
1111 "HARD_SWISH",
1112 "IF",
1113 "WHILE",
1114 "NON_MAX_SUPPRESSION_V4",
1115 "NON_MAX_SUPPRESSION_V5",
1116 "SCATTER_ND",
1117 "SELECT_V2",
1118 "DENSIFY",
1119 "SEGMENT_SUM",
1120 "BATCH_MATMUL",
1121 "PLACEHOLDER_FOR_GREATER_OP_CODES",
1122 "CUMSUM",
1123 "CALL_ONCE",
1124 "BROADCAST_TO",
1125 "RFFT2D",
1126 "CONV_3D",
1127 "IMAG",
1128 "REAL",
1129 "COMPLEX_ABS",
1130 "HASHTABLE",
1131 "HASHTABLE_FIND",
1132 "HASHTABLE_IMPORT",
1133 "HASHTABLE_SIZE",
1134 nullptr
1135 };
1136 return names;
1137}
1138
1139inline const char *EnumNameBuiltinOperator(BuiltinOperator e) {
1140 if (flatbuffers::IsOutRange(e, BuiltinOperator_ADD, BuiltinOperator_HASHTABLE_SIZE)) return "";
1141 const size_t index = static_cast<size_t>(e);
1142 return EnumNamesBuiltinOperator()[index];
1143}
1144
1145enum BuiltinOptions {
1146 BuiltinOptions_NONE = 0,
1147 BuiltinOptions_Conv2DOptions = 1,
1148 BuiltinOptions_DepthwiseConv2DOptions = 2,
1149 BuiltinOptions_ConcatEmbeddingsOptions = 3,
1150 BuiltinOptions_LSHProjectionOptions = 4,
1151 BuiltinOptions_Pool2DOptions = 5,
1152 BuiltinOptions_SVDFOptions = 6,
1153 BuiltinOptions_RNNOptions = 7,
1154 BuiltinOptions_FullyConnectedOptions = 8,
1155 BuiltinOptions_SoftmaxOptions = 9,
1156 BuiltinOptions_ConcatenationOptions = 10,
1157 BuiltinOptions_AddOptions = 11,
1158 BuiltinOptions_L2NormOptions = 12,
1159 BuiltinOptions_LocalResponseNormalizationOptions = 13,
1160 BuiltinOptions_LSTMOptions = 14,
1161 BuiltinOptions_ResizeBilinearOptions = 15,
1162 BuiltinOptions_CallOptions = 16,
1163 BuiltinOptions_ReshapeOptions = 17,
1164 BuiltinOptions_SkipGramOptions = 18,
1165 BuiltinOptions_SpaceToDepthOptions = 19,
1166 BuiltinOptions_EmbeddingLookupSparseOptions = 20,
1167 BuiltinOptions_MulOptions = 21,
1168 BuiltinOptions_PadOptions = 22,
1169 BuiltinOptions_GatherOptions = 23,
1170 BuiltinOptions_BatchToSpaceNDOptions = 24,
1171 BuiltinOptions_SpaceToBatchNDOptions = 25,
1172 BuiltinOptions_TransposeOptions = 26,
1173 BuiltinOptions_ReducerOptions = 27,
1174 BuiltinOptions_SubOptions = 28,
1175 BuiltinOptions_DivOptions = 29,
1176 BuiltinOptions_SqueezeOptions = 30,
1177 BuiltinOptions_SequenceRNNOptions = 31,
1178 BuiltinOptions_StridedSliceOptions = 32,
1179 BuiltinOptions_ExpOptions = 33,
1180 BuiltinOptions_TopKV2Options = 34,
1181 BuiltinOptions_SplitOptions = 35,
1182 BuiltinOptions_LogSoftmaxOptions = 36,
1183 BuiltinOptions_CastOptions = 37,
1184 BuiltinOptions_DequantizeOptions = 38,
1185 BuiltinOptions_MaximumMinimumOptions = 39,
1186 BuiltinOptions_ArgMaxOptions = 40,
1187 BuiltinOptions_LessOptions = 41,
1188 BuiltinOptions_NegOptions = 42,
1189 BuiltinOptions_PadV2Options = 43,
1190 BuiltinOptions_GreaterOptions = 44,
1191 BuiltinOptions_GreaterEqualOptions = 45,
1192 BuiltinOptions_LessEqualOptions = 46,
1193 BuiltinOptions_SelectOptions = 47,
1194 BuiltinOptions_SliceOptions = 48,
1195 BuiltinOptions_TransposeConvOptions = 49,
1196 BuiltinOptions_SparseToDenseOptions = 50,
1197 BuiltinOptions_TileOptions = 51,
1198 BuiltinOptions_ExpandDimsOptions = 52,
1199 BuiltinOptions_EqualOptions = 53,
1200 BuiltinOptions_NotEqualOptions = 54,
1201 BuiltinOptions_ShapeOptions = 55,
1202 BuiltinOptions_PowOptions = 56,
1203 BuiltinOptions_ArgMinOptions = 57,
1204 BuiltinOptions_FakeQuantOptions = 58,
1205 BuiltinOptions_PackOptions = 59,
1206 BuiltinOptions_LogicalOrOptions = 60,
1207 BuiltinOptions_OneHotOptions = 61,
1208 BuiltinOptions_LogicalAndOptions = 62,
1209 BuiltinOptions_LogicalNotOptions = 63,
1210 BuiltinOptions_UnpackOptions = 64,
1211 BuiltinOptions_FloorDivOptions = 65,
1212 BuiltinOptions_SquareOptions = 66,
1213 BuiltinOptions_ZerosLikeOptions = 67,
1214 BuiltinOptions_FillOptions = 68,
1215 BuiltinOptions_BidirectionalSequenceLSTMOptions = 69,
1216 BuiltinOptions_BidirectionalSequenceRNNOptions = 70,
1217 BuiltinOptions_UnidirectionalSequenceLSTMOptions = 71,
1218 BuiltinOptions_FloorModOptions = 72,
1219 BuiltinOptions_RangeOptions = 73,
1220 BuiltinOptions_ResizeNearestNeighborOptions = 74,
1221 BuiltinOptions_LeakyReluOptions = 75,
1222 BuiltinOptions_SquaredDifferenceOptions = 76,
1223 BuiltinOptions_MirrorPadOptions = 77,
1224 BuiltinOptions_AbsOptions = 78,
1225 BuiltinOptions_SplitVOptions = 79,
1226 BuiltinOptions_UniqueOptions = 80,
1227 BuiltinOptions_ReverseV2Options = 81,
1228 BuiltinOptions_AddNOptions = 82,
1229 BuiltinOptions_GatherNdOptions = 83,
1230 BuiltinOptions_CosOptions = 84,
1231 BuiltinOptions_WhereOptions = 85,
1232 BuiltinOptions_RankOptions = 86,
1233 BuiltinOptions_ReverseSequenceOptions = 87,
1234 BuiltinOptions_MatrixDiagOptions = 88,
1235 BuiltinOptions_QuantizeOptions = 89,
1236 BuiltinOptions_MatrixSetDiagOptions = 90,
1237 BuiltinOptions_HardSwishOptions = 91,
1238 BuiltinOptions_IfOptions = 92,
1239 BuiltinOptions_WhileOptions = 93,
1240 BuiltinOptions_DepthToSpaceOptions = 94,
1241 BuiltinOptions_NonMaxSuppressionV4Options = 95,
1242 BuiltinOptions_NonMaxSuppressionV5Options = 96,
1243 BuiltinOptions_ScatterNdOptions = 97,
1244 BuiltinOptions_SelectV2Options = 98,
1245 BuiltinOptions_DensifyOptions = 99,
1246 BuiltinOptions_SegmentSumOptions = 100,
1247 BuiltinOptions_BatchMatMulOptions = 101,
1248 BuiltinOptions_CumsumOptions = 102,
1249 BuiltinOptions_CallOnceOptions = 103,
1250 BuiltinOptions_BroadcastToOptions = 104,
1251 BuiltinOptions_Rfft2dOptions = 105,
1252 BuiltinOptions_Conv3DOptions = 106,
1253 BuiltinOptions_HashtableOptions = 107,
1254 BuiltinOptions_HashtableFindOptions = 108,
1255 BuiltinOptions_HashtableImportOptions = 109,
1256 BuiltinOptions_HashtableSizeOptions = 110,
1257 BuiltinOptions_MIN = BuiltinOptions_NONE,
1258 BuiltinOptions_MAX = BuiltinOptions_HashtableSizeOptions
1259};
1260
1261inline const BuiltinOptions (&EnumValuesBuiltinOptions())[111] {
1262 static const BuiltinOptions values[] = {
1263 BuiltinOptions_NONE,
1264 BuiltinOptions_Conv2DOptions,
1265 BuiltinOptions_DepthwiseConv2DOptions,
1266 BuiltinOptions_ConcatEmbeddingsOptions,
1267 BuiltinOptions_LSHProjectionOptions,
1268 BuiltinOptions_Pool2DOptions,
1269 BuiltinOptions_SVDFOptions,
1270 BuiltinOptions_RNNOptions,
1271 BuiltinOptions_FullyConnectedOptions,
1272 BuiltinOptions_SoftmaxOptions,
1273 BuiltinOptions_ConcatenationOptions,
1274 BuiltinOptions_AddOptions,
1275 BuiltinOptions_L2NormOptions,
1276 BuiltinOptions_LocalResponseNormalizationOptions,
1277 BuiltinOptions_LSTMOptions,
1278 BuiltinOptions_ResizeBilinearOptions,
1279 BuiltinOptions_CallOptions,
1280 BuiltinOptions_ReshapeOptions,
1281 BuiltinOptions_SkipGramOptions,
1282 BuiltinOptions_SpaceToDepthOptions,
1283 BuiltinOptions_EmbeddingLookupSparseOptions,
1284 BuiltinOptions_MulOptions,
1285 BuiltinOptions_PadOptions,
1286 BuiltinOptions_GatherOptions,
1287 BuiltinOptions_BatchToSpaceNDOptions,
1288 BuiltinOptions_SpaceToBatchNDOptions,
1289 BuiltinOptions_TransposeOptions,
1290 BuiltinOptions_ReducerOptions,
1291 BuiltinOptions_SubOptions,
1292 BuiltinOptions_DivOptions,
1293 BuiltinOptions_SqueezeOptions,
1294 BuiltinOptions_SequenceRNNOptions,
1295 BuiltinOptions_StridedSliceOptions,
1296 BuiltinOptions_ExpOptions,
1297 BuiltinOptions_TopKV2Options,
1298 BuiltinOptions_SplitOptions,
1299 BuiltinOptions_LogSoftmaxOptions,
1300 BuiltinOptions_CastOptions,
1301 BuiltinOptions_DequantizeOptions,
1302 BuiltinOptions_MaximumMinimumOptions,
1303 BuiltinOptions_ArgMaxOptions,
1304 BuiltinOptions_LessOptions,
1305 BuiltinOptions_NegOptions,
1306 BuiltinOptions_PadV2Options,
1307 BuiltinOptions_GreaterOptions,
1308 BuiltinOptions_GreaterEqualOptions,
1309 BuiltinOptions_LessEqualOptions,
1310 BuiltinOptions_SelectOptions,
1311 BuiltinOptions_SliceOptions,
1312 BuiltinOptions_TransposeConvOptions,
1313 BuiltinOptions_SparseToDenseOptions,
1314 BuiltinOptions_TileOptions,
1315 BuiltinOptions_ExpandDimsOptions,
1316 BuiltinOptions_EqualOptions,
1317 BuiltinOptions_NotEqualOptions,
1318 BuiltinOptions_ShapeOptions,
1319 BuiltinOptions_PowOptions,
1320 BuiltinOptions_ArgMinOptions,
1321 BuiltinOptions_FakeQuantOptions,
1322 BuiltinOptions_PackOptions,
1323 BuiltinOptions_LogicalOrOptions,
1324 BuiltinOptions_OneHotOptions,
1325 BuiltinOptions_LogicalAndOptions,
1326 BuiltinOptions_LogicalNotOptions,
1327 BuiltinOptions_UnpackOptions,
1328 BuiltinOptions_FloorDivOptions,
1329 BuiltinOptions_SquareOptions,
1330 BuiltinOptions_ZerosLikeOptions,
1331 BuiltinOptions_FillOptions,
1332 BuiltinOptions_BidirectionalSequenceLSTMOptions,
1333 BuiltinOptions_BidirectionalSequenceRNNOptions,
1334 BuiltinOptions_UnidirectionalSequenceLSTMOptions,
1335 BuiltinOptions_FloorModOptions,
1336 BuiltinOptions_RangeOptions,
1337 BuiltinOptions_ResizeNearestNeighborOptions,
1338 BuiltinOptions_LeakyReluOptions,
1339 BuiltinOptions_SquaredDifferenceOptions,
1340 BuiltinOptions_MirrorPadOptions,
1341 BuiltinOptions_AbsOptions,
1342 BuiltinOptions_SplitVOptions,
1343 BuiltinOptions_UniqueOptions,
1344 BuiltinOptions_ReverseV2Options,
1345 BuiltinOptions_AddNOptions,
1346 BuiltinOptions_GatherNdOptions,
1347 BuiltinOptions_CosOptions,
1348 BuiltinOptions_WhereOptions,
1349 BuiltinOptions_RankOptions,
1350 BuiltinOptions_ReverseSequenceOptions,
1351 BuiltinOptions_MatrixDiagOptions,
1352 BuiltinOptions_QuantizeOptions,
1353 BuiltinOptions_MatrixSetDiagOptions,
1354 BuiltinOptions_HardSwishOptions,
1355 BuiltinOptions_IfOptions,
1356 BuiltinOptions_WhileOptions,
1357 BuiltinOptions_DepthToSpaceOptions,
1358 BuiltinOptions_NonMaxSuppressionV4Options,
1359 BuiltinOptions_NonMaxSuppressionV5Options,
1360 BuiltinOptions_ScatterNdOptions,
1361 BuiltinOptions_SelectV2Options,
1362 BuiltinOptions_DensifyOptions,
1363 BuiltinOptions_SegmentSumOptions,
1364 BuiltinOptions_BatchMatMulOptions,
1365 BuiltinOptions_CumsumOptions,
1366 BuiltinOptions_CallOnceOptions,
1367 BuiltinOptions_BroadcastToOptions,
1368 BuiltinOptions_Rfft2dOptions,
1369 BuiltinOptions_Conv3DOptions,
1370 BuiltinOptions_HashtableOptions,
1371 BuiltinOptions_HashtableFindOptions,
1372 BuiltinOptions_HashtableImportOptions,
1373 BuiltinOptions_HashtableSizeOptions
1374 };
1375 return values;
1376}
1377
1378inline const char * const *EnumNamesBuiltinOptions() {
1379 static const char * const names[112] = {
1380 "NONE",
1381 "Conv2DOptions",
1382 "DepthwiseConv2DOptions",
1383 "ConcatEmbeddingsOptions",
1384 "LSHProjectionOptions",
1385 "Pool2DOptions",
1386 "SVDFOptions",
1387 "RNNOptions",
1388 "FullyConnectedOptions",
1389 "SoftmaxOptions",
1390 "ConcatenationOptions",
1391 "AddOptions",
1392 "L2NormOptions",
1393 "LocalResponseNormalizationOptions",
1394 "LSTMOptions",
1395 "ResizeBilinearOptions",
1396 "CallOptions",
1397 "ReshapeOptions",
1398 "SkipGramOptions",
1399 "SpaceToDepthOptions",
1400 "EmbeddingLookupSparseOptions",
1401 "MulOptions",
1402 "PadOptions",
1403 "GatherOptions",
1404 "BatchToSpaceNDOptions",
1405 "SpaceToBatchNDOptions",
1406 "TransposeOptions",
1407 "ReducerOptions",
1408 "SubOptions",
1409 "DivOptions",
1410 "SqueezeOptions",
1411 "SequenceRNNOptions",
1412 "StridedSliceOptions",
1413 "ExpOptions",
1414 "TopKV2Options",
1415 "SplitOptions",
1416 "LogSoftmaxOptions",
1417 "CastOptions",
1418 "DequantizeOptions",
1419 "MaximumMinimumOptions",
1420 "ArgMaxOptions",
1421 "LessOptions",
1422 "NegOptions",
1423 "PadV2Options",
1424 "GreaterOptions",
1425 "GreaterEqualOptions",
1426 "LessEqualOptions",
1427 "SelectOptions",
1428 "SliceOptions",
1429 "TransposeConvOptions",
1430 "SparseToDenseOptions",
1431 "TileOptions",
1432 "ExpandDimsOptions",
1433 "EqualOptions",
1434 "NotEqualOptions",
1435 "ShapeOptions",
1436 "PowOptions",
1437 "ArgMinOptions",
1438 "FakeQuantOptions",
1439 "PackOptions",
1440 "LogicalOrOptions",
1441 "OneHotOptions",
1442 "LogicalAndOptions",
1443 "LogicalNotOptions",
1444 "UnpackOptions",
1445 "FloorDivOptions",
1446 "SquareOptions",
1447 "ZerosLikeOptions",
1448 "FillOptions",
1449 "BidirectionalSequenceLSTMOptions",
1450 "BidirectionalSequenceRNNOptions",
1451 "UnidirectionalSequenceLSTMOptions",
1452 "FloorModOptions",
1453 "RangeOptions",
1454 "ResizeNearestNeighborOptions",
1455 "LeakyReluOptions",
1456 "SquaredDifferenceOptions",
1457 "MirrorPadOptions",
1458 "AbsOptions",
1459 "SplitVOptions",
1460 "UniqueOptions",
1461 "ReverseV2Options",
1462 "AddNOptions",
1463 "GatherNdOptions",
1464 "CosOptions",
1465 "WhereOptions",
1466 "RankOptions",
1467 "ReverseSequenceOptions",
1468 "MatrixDiagOptions",
1469 "QuantizeOptions",
1470 "MatrixSetDiagOptions",
1471 "HardSwishOptions",
1472 "IfOptions",
1473 "WhileOptions",
1474 "DepthToSpaceOptions",
1475 "NonMaxSuppressionV4Options",
1476 "NonMaxSuppressionV5Options",
1477 "ScatterNdOptions",
1478 "SelectV2Options",
1479 "DensifyOptions",
1480 "SegmentSumOptions",
1481 "BatchMatMulOptions",
1482 "CumsumOptions",
1483 "CallOnceOptions",
1484 "BroadcastToOptions",
1485 "Rfft2dOptions",
1486 "Conv3DOptions",
1487 "HashtableOptions",
1488 "HashtableFindOptions",
1489 "HashtableImportOptions",
1490 "HashtableSizeOptions",
1491 nullptr
1492 };
1493 return names;
1494}
1495
1496inline const char *EnumNameBuiltinOptions(BuiltinOptions e) {
1497 if (flatbuffers::IsOutRange(e, BuiltinOptions_NONE, BuiltinOptions_HashtableSizeOptions)) return "";
1498 const size_t index = static_cast<size_t>(e);
1499 return EnumNamesBuiltinOptions()[index];
1500}
1501
1502template<typename T> struct BuiltinOptionsTraits {
1503 static const BuiltinOptions enum_value = BuiltinOptions_NONE;
1504};
1505
1506template<> struct BuiltinOptionsTraits<tflite::Conv2DOptions> {
1507 static const BuiltinOptions enum_value = BuiltinOptions_Conv2DOptions;
1508};
1509
1510template<> struct BuiltinOptionsTraits<tflite::DepthwiseConv2DOptions> {
1511 static const BuiltinOptions enum_value = BuiltinOptions_DepthwiseConv2DOptions;
1512};
1513
1514template<> struct BuiltinOptionsTraits<tflite::ConcatEmbeddingsOptions> {
1515 static const BuiltinOptions enum_value = BuiltinOptions_ConcatEmbeddingsOptions;
1516};
1517
1518template<> struct BuiltinOptionsTraits<tflite::LSHProjectionOptions> {
1519 static const BuiltinOptions enum_value = BuiltinOptions_LSHProjectionOptions;
1520};
1521
1522template<> struct BuiltinOptionsTraits<tflite::Pool2DOptions> {
1523 static const BuiltinOptions enum_value = BuiltinOptions_Pool2DOptions;
1524};
1525
1526template<> struct BuiltinOptionsTraits<tflite::SVDFOptions> {
1527 static const BuiltinOptions enum_value = BuiltinOptions_SVDFOptions;
1528};
1529
1530template<> struct BuiltinOptionsTraits<tflite::RNNOptions> {
1531 static const BuiltinOptions enum_value = BuiltinOptions_RNNOptions;
1532};
1533
1534template<> struct BuiltinOptionsTraits<tflite::FullyConnectedOptions> {
1535 static const BuiltinOptions enum_value = BuiltinOptions_FullyConnectedOptions;
1536};
1537
1538template<> struct BuiltinOptionsTraits<tflite::SoftmaxOptions> {
1539 static const BuiltinOptions enum_value = BuiltinOptions_SoftmaxOptions;
1540};
1541
1542template<> struct BuiltinOptionsTraits<tflite::ConcatenationOptions> {
1543 static const BuiltinOptions enum_value = BuiltinOptions_ConcatenationOptions;
1544};
1545
1546template<> struct BuiltinOptionsTraits<tflite::AddOptions> {
1547 static const BuiltinOptions enum_value = BuiltinOptions_AddOptions;
1548};
1549
1550template<> struct BuiltinOptionsTraits<tflite::L2NormOptions> {
1551 static const BuiltinOptions enum_value = BuiltinOptions_L2NormOptions;
1552};
1553
1554template<> struct BuiltinOptionsTraits<tflite::LocalResponseNormalizationOptions> {
1555 static const BuiltinOptions enum_value = BuiltinOptions_LocalResponseNormalizationOptions;
1556};
1557
1558template<> struct BuiltinOptionsTraits<tflite::LSTMOptions> {
1559 static const BuiltinOptions enum_value = BuiltinOptions_LSTMOptions;
1560};
1561
1562template<> struct BuiltinOptionsTraits<tflite::ResizeBilinearOptions> {
1563 static const BuiltinOptions enum_value = BuiltinOptions_ResizeBilinearOptions;
1564};
1565
1566template<> struct BuiltinOptionsTraits<tflite::CallOptions> {
1567 static const BuiltinOptions enum_value = BuiltinOptions_CallOptions;
1568};
1569
1570template<> struct BuiltinOptionsTraits<tflite::ReshapeOptions> {
1571 static const BuiltinOptions enum_value = BuiltinOptions_ReshapeOptions;
1572};
1573
1574template<> struct BuiltinOptionsTraits<tflite::SkipGramOptions> {
1575 static const BuiltinOptions enum_value = BuiltinOptions_SkipGramOptions;
1576};
1577
1578template<> struct BuiltinOptionsTraits<tflite::SpaceToDepthOptions> {
1579 static const BuiltinOptions enum_value = BuiltinOptions_SpaceToDepthOptions;
1580};
1581
1582template<> struct BuiltinOptionsTraits<tflite::EmbeddingLookupSparseOptions> {
1583 static const BuiltinOptions enum_value = BuiltinOptions_EmbeddingLookupSparseOptions;
1584};
1585
1586template<> struct BuiltinOptionsTraits<tflite::MulOptions> {
1587 static const BuiltinOptions enum_value = BuiltinOptions_MulOptions;
1588};
1589
1590template<> struct BuiltinOptionsTraits<tflite::PadOptions> {
1591 static const BuiltinOptions enum_value = BuiltinOptions_PadOptions;
1592};
1593
1594template<> struct BuiltinOptionsTraits<tflite::GatherOptions> {
1595 static const BuiltinOptions enum_value = BuiltinOptions_GatherOptions;
1596};
1597
1598template<> struct BuiltinOptionsTraits<tflite::BatchToSpaceNDOptions> {
1599 static const BuiltinOptions enum_value = BuiltinOptions_BatchToSpaceNDOptions;
1600};
1601
1602template<> struct BuiltinOptionsTraits<tflite::SpaceToBatchNDOptions> {
1603 static const BuiltinOptions enum_value = BuiltinOptions_SpaceToBatchNDOptions;
1604};
1605
1606template<> struct BuiltinOptionsTraits<tflite::TransposeOptions> {
1607 static const BuiltinOptions enum_value = BuiltinOptions_TransposeOptions;
1608};
1609
1610template<> struct BuiltinOptionsTraits<tflite::ReducerOptions> {
1611 static const BuiltinOptions enum_value = BuiltinOptions_ReducerOptions;
1612};
1613
1614template<> struct BuiltinOptionsTraits<tflite::SubOptions> {
1615 static const BuiltinOptions enum_value = BuiltinOptions_SubOptions;
1616};
1617
1618template<> struct BuiltinOptionsTraits<tflite::DivOptions> {
1619 static const BuiltinOptions enum_value = BuiltinOptions_DivOptions;
1620};
1621
1622template<> struct BuiltinOptionsTraits<tflite::SqueezeOptions> {
1623 static const BuiltinOptions enum_value = BuiltinOptions_SqueezeOptions;
1624};
1625
1626template<> struct BuiltinOptionsTraits<tflite::SequenceRNNOptions> {
1627 static const BuiltinOptions enum_value = BuiltinOptions_SequenceRNNOptions;
1628};
1629
1630template<> struct BuiltinOptionsTraits<tflite::StridedSliceOptions> {
1631 static const BuiltinOptions enum_value = BuiltinOptions_StridedSliceOptions;
1632};
1633
1634template<> struct BuiltinOptionsTraits<tflite::ExpOptions> {
1635 static const BuiltinOptions enum_value = BuiltinOptions_ExpOptions;
1636};
1637
1638template<> struct BuiltinOptionsTraits<tflite::TopKV2Options> {
1639 static const BuiltinOptions enum_value = BuiltinOptions_TopKV2Options;
1640};
1641
1642template<> struct BuiltinOptionsTraits<tflite::SplitOptions> {
1643 static const BuiltinOptions enum_value = BuiltinOptions_SplitOptions;
1644};
1645
1646template<> struct BuiltinOptionsTraits<tflite::LogSoftmaxOptions> {
1647 static const BuiltinOptions enum_value = BuiltinOptions_LogSoftmaxOptions;
1648};
1649
1650template<> struct BuiltinOptionsTraits<tflite::CastOptions> {
1651 static const BuiltinOptions enum_value = BuiltinOptions_CastOptions;
1652};
1653
1654template<> struct BuiltinOptionsTraits<tflite::DequantizeOptions> {
1655 static const BuiltinOptions enum_value = BuiltinOptions_DequantizeOptions;
1656};
1657
1658template<> struct BuiltinOptionsTraits<tflite::MaximumMinimumOptions> {
1659 static const BuiltinOptions enum_value = BuiltinOptions_MaximumMinimumOptions;
1660};
1661
1662template<> struct BuiltinOptionsTraits<tflite::ArgMaxOptions> {
1663 static const BuiltinOptions enum_value = BuiltinOptions_ArgMaxOptions;
1664};
1665
1666template<> struct BuiltinOptionsTraits<tflite::LessOptions> {
1667 static const BuiltinOptions enum_value = BuiltinOptions_LessOptions;
1668};
1669
1670template<> struct BuiltinOptionsTraits<tflite::NegOptions> {
1671 static const BuiltinOptions enum_value = BuiltinOptions_NegOptions;
1672};
1673
1674template<> struct BuiltinOptionsTraits<tflite::PadV2Options> {
1675 static const BuiltinOptions enum_value = BuiltinOptions_PadV2Options;
1676};
1677
1678template<> struct BuiltinOptionsTraits<tflite::GreaterOptions> {
1679 static const BuiltinOptions enum_value = BuiltinOptions_GreaterOptions;
1680};
1681
1682template<> struct BuiltinOptionsTraits<tflite::GreaterEqualOptions> {
1683 static const BuiltinOptions enum_value = BuiltinOptions_GreaterEqualOptions;
1684};
1685
1686template<> struct BuiltinOptionsTraits<tflite::LessEqualOptions> {
1687 static const BuiltinOptions enum_value = BuiltinOptions_LessEqualOptions;
1688};
1689
1690template<> struct BuiltinOptionsTraits<tflite::SelectOptions> {
1691 static const BuiltinOptions enum_value = BuiltinOptions_SelectOptions;
1692};
1693
1694template<> struct BuiltinOptionsTraits<tflite::SliceOptions> {
1695 static const BuiltinOptions enum_value = BuiltinOptions_SliceOptions;
1696};
1697
1698template<> struct BuiltinOptionsTraits<tflite::TransposeConvOptions> {
1699 static const BuiltinOptions enum_value = BuiltinOptions_TransposeConvOptions;
1700};
1701
1702template<> struct BuiltinOptionsTraits<tflite::SparseToDenseOptions> {
1703 static const BuiltinOptions enum_value = BuiltinOptions_SparseToDenseOptions;
1704};
1705
1706template<> struct BuiltinOptionsTraits<tflite::TileOptions> {
1707 static const BuiltinOptions enum_value = BuiltinOptions_TileOptions;
1708};
1709
1710template<> struct BuiltinOptionsTraits<tflite::ExpandDimsOptions> {
1711 static const BuiltinOptions enum_value = BuiltinOptions_ExpandDimsOptions;
1712};
1713
1714template<> struct BuiltinOptionsTraits<tflite::EqualOptions> {
1715 static const BuiltinOptions enum_value = BuiltinOptions_EqualOptions;
1716};
1717
1718template<> struct BuiltinOptionsTraits<tflite::NotEqualOptions> {
1719 static const BuiltinOptions enum_value = BuiltinOptions_NotEqualOptions;
1720};
1721
1722template<> struct BuiltinOptionsTraits<tflite::ShapeOptions> {
1723 static const BuiltinOptions enum_value = BuiltinOptions_ShapeOptions;
1724};
1725
1726template<> struct BuiltinOptionsTraits<tflite::PowOptions> {
1727 static const BuiltinOptions enum_value = BuiltinOptions_PowOptions;
1728};
1729
1730template<> struct BuiltinOptionsTraits<tflite::ArgMinOptions> {
1731 static const BuiltinOptions enum_value = BuiltinOptions_ArgMinOptions;
1732};
1733
1734template<> struct BuiltinOptionsTraits<tflite::FakeQuantOptions> {
1735 static const BuiltinOptions enum_value = BuiltinOptions_FakeQuantOptions;
1736};
1737
1738template<> struct BuiltinOptionsTraits<tflite::PackOptions> {
1739 static const BuiltinOptions enum_value = BuiltinOptions_PackOptions;
1740};
1741
1742template<> struct BuiltinOptionsTraits<tflite::LogicalOrOptions> {
1743 static const BuiltinOptions enum_value = BuiltinOptions_LogicalOrOptions;
1744};
1745
1746template<> struct BuiltinOptionsTraits<tflite::OneHotOptions> {
1747 static const BuiltinOptions enum_value = BuiltinOptions_OneHotOptions;
1748};
1749
1750template<> struct BuiltinOptionsTraits<tflite::LogicalAndOptions> {
1751 static const BuiltinOptions enum_value = BuiltinOptions_LogicalAndOptions;
1752};
1753
1754template<> struct BuiltinOptionsTraits<tflite::LogicalNotOptions> {
1755 static const BuiltinOptions enum_value = BuiltinOptions_LogicalNotOptions;
1756};
1757
1758template<> struct BuiltinOptionsTraits<tflite::UnpackOptions> {
1759 static const BuiltinOptions enum_value = BuiltinOptions_UnpackOptions;
1760};
1761
1762template<> struct BuiltinOptionsTraits<tflite::FloorDivOptions> {
1763 static const BuiltinOptions enum_value = BuiltinOptions_FloorDivOptions;
1764};
1765
1766template<> struct BuiltinOptionsTraits<tflite::SquareOptions> {
1767 static const BuiltinOptions enum_value = BuiltinOptions_SquareOptions;
1768};
1769
1770template<> struct BuiltinOptionsTraits<tflite::ZerosLikeOptions> {
1771 static const BuiltinOptions enum_value = BuiltinOptions_ZerosLikeOptions;
1772};
1773
1774template<> struct BuiltinOptionsTraits<tflite::FillOptions> {
1775 static const BuiltinOptions enum_value = BuiltinOptions_FillOptions;
1776};
1777
1778template<> struct BuiltinOptionsTraits<tflite::BidirectionalSequenceLSTMOptions> {
1779 static const BuiltinOptions enum_value = BuiltinOptions_BidirectionalSequenceLSTMOptions;
1780};
1781
1782template<> struct BuiltinOptionsTraits<tflite::BidirectionalSequenceRNNOptions> {
1783 static const BuiltinOptions enum_value = BuiltinOptions_BidirectionalSequenceRNNOptions;
1784};
1785
1786template<> struct BuiltinOptionsTraits<tflite::UnidirectionalSequenceLSTMOptions> {
1787 static const BuiltinOptions enum_value = BuiltinOptions_UnidirectionalSequenceLSTMOptions;
1788};
1789
1790template<> struct BuiltinOptionsTraits<tflite::FloorModOptions> {
1791 static const BuiltinOptions enum_value = BuiltinOptions_FloorModOptions;
1792};
1793
1794template<> struct BuiltinOptionsTraits<tflite::RangeOptions> {
1795 static const BuiltinOptions enum_value = BuiltinOptions_RangeOptions;
1796};
1797
1798template<> struct BuiltinOptionsTraits<tflite::ResizeNearestNeighborOptions> {
1799 static const BuiltinOptions enum_value = BuiltinOptions_ResizeNearestNeighborOptions;
1800};
1801
1802template<> struct BuiltinOptionsTraits<tflite::LeakyReluOptions> {
1803 static const BuiltinOptions enum_value = BuiltinOptions_LeakyReluOptions;
1804};
1805
1806template<> struct BuiltinOptionsTraits<tflite::SquaredDifferenceOptions> {
1807 static const BuiltinOptions enum_value = BuiltinOptions_SquaredDifferenceOptions;
1808};
1809
1810template<> struct BuiltinOptionsTraits<tflite::MirrorPadOptions> {
1811 static const BuiltinOptions enum_value = BuiltinOptions_MirrorPadOptions;
1812};
1813
1814template<> struct BuiltinOptionsTraits<tflite::AbsOptions> {
1815 static const BuiltinOptions enum_value = BuiltinOptions_AbsOptions;
1816};
1817
1818template<> struct BuiltinOptionsTraits<tflite::SplitVOptions> {
1819 static const BuiltinOptions enum_value = BuiltinOptions_SplitVOptions;
1820};
1821
1822template<> struct BuiltinOptionsTraits<tflite::UniqueOptions> {
1823 static const BuiltinOptions enum_value = BuiltinOptions_UniqueOptions;
1824};
1825
1826template<> struct BuiltinOptionsTraits<tflite::ReverseV2Options> {
1827 static const BuiltinOptions enum_value = BuiltinOptions_ReverseV2Options;
1828};
1829
1830template<> struct BuiltinOptionsTraits<tflite::AddNOptions> {
1831 static const BuiltinOptions enum_value = BuiltinOptions_AddNOptions;
1832};
1833
1834template<> struct BuiltinOptionsTraits<tflite::GatherNdOptions> {
1835 static const BuiltinOptions enum_value = BuiltinOptions_GatherNdOptions;
1836};
1837
1838template<> struct BuiltinOptionsTraits<tflite::CosOptions> {
1839 static const BuiltinOptions enum_value = BuiltinOptions_CosOptions;
1840};
1841
1842template<> struct BuiltinOptionsTraits<tflite::WhereOptions> {
1843 static const BuiltinOptions enum_value = BuiltinOptions_WhereOptions;
1844};
1845
1846template<> struct BuiltinOptionsTraits<tflite::RankOptions> {
1847 static const BuiltinOptions enum_value = BuiltinOptions_RankOptions;
1848};
1849
1850template<> struct BuiltinOptionsTraits<tflite::ReverseSequenceOptions> {
1851 static const BuiltinOptions enum_value = BuiltinOptions_ReverseSequenceOptions;
1852};
1853
1854template<> struct BuiltinOptionsTraits<tflite::MatrixDiagOptions> {
1855 static const BuiltinOptions enum_value = BuiltinOptions_MatrixDiagOptions;
1856};
1857
1858template<> struct BuiltinOptionsTraits<tflite::QuantizeOptions> {
1859 static const BuiltinOptions enum_value = BuiltinOptions_QuantizeOptions;
1860};
1861
1862template<> struct BuiltinOptionsTraits<tflite::MatrixSetDiagOptions> {
1863 static const BuiltinOptions enum_value = BuiltinOptions_MatrixSetDiagOptions;
1864};
1865
1866template<> struct BuiltinOptionsTraits<tflite::HardSwishOptions> {
1867 static const BuiltinOptions enum_value = BuiltinOptions_HardSwishOptions;
1868};
1869
1870template<> struct BuiltinOptionsTraits<tflite::IfOptions> {
1871 static const BuiltinOptions enum_value = BuiltinOptions_IfOptions;
1872};
1873
1874template<> struct BuiltinOptionsTraits<tflite::WhileOptions> {
1875 static const BuiltinOptions enum_value = BuiltinOptions_WhileOptions;
1876};
1877
1878template<> struct BuiltinOptionsTraits<tflite::DepthToSpaceOptions> {
1879 static const BuiltinOptions enum_value = BuiltinOptions_DepthToSpaceOptions;
1880};
1881
1882template<> struct BuiltinOptionsTraits<tflite::NonMaxSuppressionV4Options> {
1883 static const BuiltinOptions enum_value = BuiltinOptions_NonMaxSuppressionV4Options;
1884};
1885
1886template<> struct BuiltinOptionsTraits<tflite::NonMaxSuppressionV5Options> {
1887 static const BuiltinOptions enum_value = BuiltinOptions_NonMaxSuppressionV5Options;
1888};
1889
1890template<> struct BuiltinOptionsTraits<tflite::ScatterNdOptions> {
1891 static const BuiltinOptions enum_value = BuiltinOptions_ScatterNdOptions;
1892};
1893
1894template<> struct BuiltinOptionsTraits<tflite::SelectV2Options> {
1895 static const BuiltinOptions enum_value = BuiltinOptions_SelectV2Options;
1896};
1897
1898template<> struct BuiltinOptionsTraits<tflite::DensifyOptions> {
1899 static const BuiltinOptions enum_value = BuiltinOptions_DensifyOptions;
1900};
1901
1902template<> struct BuiltinOptionsTraits<tflite::SegmentSumOptions> {
1903 static const BuiltinOptions enum_value = BuiltinOptions_SegmentSumOptions;
1904};
1905
1906template<> struct BuiltinOptionsTraits<tflite::BatchMatMulOptions> {
1907 static const BuiltinOptions enum_value = BuiltinOptions_BatchMatMulOptions;
1908};
1909
1910template<> struct BuiltinOptionsTraits<tflite::CumsumOptions> {
1911 static const BuiltinOptions enum_value = BuiltinOptions_CumsumOptions;
1912};
1913
1914template<> struct BuiltinOptionsTraits<tflite::CallOnceOptions> {
1915 static const BuiltinOptions enum_value = BuiltinOptions_CallOnceOptions;
1916};
1917
1918template<> struct BuiltinOptionsTraits<tflite::BroadcastToOptions> {
1919 static const BuiltinOptions enum_value = BuiltinOptions_BroadcastToOptions;
1920};
1921
1922template<> struct BuiltinOptionsTraits<tflite::Rfft2dOptions> {
1923 static const BuiltinOptions enum_value = BuiltinOptions_Rfft2dOptions;
1924};
1925
1926template<> struct BuiltinOptionsTraits<tflite::Conv3DOptions> {
1927 static const BuiltinOptions enum_value = BuiltinOptions_Conv3DOptions;
1928};
1929
1930template<> struct BuiltinOptionsTraits<tflite::HashtableOptions> {
1931 static const BuiltinOptions enum_value = BuiltinOptions_HashtableOptions;
1932};
1933
1934template<> struct BuiltinOptionsTraits<tflite::HashtableFindOptions> {
1935 static const BuiltinOptions enum_value = BuiltinOptions_HashtableFindOptions;
1936};
1937
1938template<> struct BuiltinOptionsTraits<tflite::HashtableImportOptions> {
1939 static const BuiltinOptions enum_value = BuiltinOptions_HashtableImportOptions;
1940};
1941
1942template<> struct BuiltinOptionsTraits<tflite::HashtableSizeOptions> {
1943 static const BuiltinOptions enum_value = BuiltinOptions_HashtableSizeOptions;
1944};
1945
1946struct BuiltinOptionsUnion {
1947 BuiltinOptions type;
1948 void *value;
1949
1950 BuiltinOptionsUnion() : type(BuiltinOptions_NONE), value(nullptr) {}
1951 BuiltinOptionsUnion(BuiltinOptionsUnion&& u) FLATBUFFERS_NOEXCEPT :
1952 type(BuiltinOptions_NONE), value(nullptr)
1953 { std::swap(type, u.type); std::swap(value, u.value); }
1954 BuiltinOptionsUnion(const BuiltinOptionsUnion &) FLATBUFFERS_NOEXCEPT;
1955 BuiltinOptionsUnion &operator=(const BuiltinOptionsUnion &u) FLATBUFFERS_NOEXCEPT
1956 { BuiltinOptionsUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
1957 BuiltinOptionsUnion &operator=(BuiltinOptionsUnion &&u) FLATBUFFERS_NOEXCEPT
1958 { std::swap(type, u.type); std::swap(value, u.value); return *this; }
1959 ~BuiltinOptionsUnion() { Reset(); }
1960
1961 void Reset();
1962
1963#ifndef FLATBUFFERS_CPP98_STL
1964 template <typename T>
1965 void Set(T&& val) {
1966 using RT = typename std::remove_reference<T>::type;
1967 Reset();
1968 type = BuiltinOptionsTraits<typename RT::TableType>::enum_value;
1969 if (type != BuiltinOptions_NONE) {
1970 value = new RT(std::forward<T>(val));
1971 }
1972 }
1973#endif // FLATBUFFERS_CPP98_STL
1974
1975 static void *UnPack(const void *obj, BuiltinOptions type, const flatbuffers::resolver_function_t *resolver);
1976 flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
1977
1978 tflite::Conv2DOptionsT *AsConv2DOptions() {
1979 return type == BuiltinOptions_Conv2DOptions ?
1980 reinterpret_cast<tflite::Conv2DOptionsT *>(value) : nullptr;
1981 }
1982 const tflite::Conv2DOptionsT *AsConv2DOptions() const {
1983 return type == BuiltinOptions_Conv2DOptions ?
1984 reinterpret_cast<const tflite::Conv2DOptionsT *>(value) : nullptr;
1985 }
1986 tflite::DepthwiseConv2DOptionsT *AsDepthwiseConv2DOptions() {
1987 return type == BuiltinOptions_DepthwiseConv2DOptions ?
1988 reinterpret_cast<tflite::DepthwiseConv2DOptionsT *>(value) : nullptr;
1989 }
1990 const tflite::DepthwiseConv2DOptionsT *AsDepthwiseConv2DOptions() const {
1991 return type == BuiltinOptions_DepthwiseConv2DOptions ?
1992 reinterpret_cast<const tflite::DepthwiseConv2DOptionsT *>(value) : nullptr;
1993 }
1994 tflite::ConcatEmbeddingsOptionsT *AsConcatEmbeddingsOptions() {
1995 return type == BuiltinOptions_ConcatEmbeddingsOptions ?
1996 reinterpret_cast<tflite::ConcatEmbeddingsOptionsT *>(value) : nullptr;
1997 }
1998 const tflite::ConcatEmbeddingsOptionsT *AsConcatEmbeddingsOptions() const {
1999 return type == BuiltinOptions_ConcatEmbeddingsOptions ?
2000 reinterpret_cast<const tflite::ConcatEmbeddingsOptionsT *>(value) : nullptr;
2001 }
2002 tflite::LSHProjectionOptionsT *AsLSHProjectionOptions() {
2003 return type == BuiltinOptions_LSHProjectionOptions ?
2004 reinterpret_cast<tflite::LSHProjectionOptionsT *>(value) : nullptr;
2005 }
2006 const tflite::LSHProjectionOptionsT *AsLSHProjectionOptions() const {
2007 return type == BuiltinOptions_LSHProjectionOptions ?
2008 reinterpret_cast<const tflite::LSHProjectionOptionsT *>(value) : nullptr;
2009 }
2010 tflite::Pool2DOptionsT *AsPool2DOptions() {
2011 return type == BuiltinOptions_Pool2DOptions ?
2012 reinterpret_cast<tflite::Pool2DOptionsT *>(value) : nullptr;
2013 }
2014 const tflite::Pool2DOptionsT *AsPool2DOptions() const {
2015 return type == BuiltinOptions_Pool2DOptions ?
2016 reinterpret_cast<const tflite::Pool2DOptionsT *>(value) : nullptr;
2017 }
2018 tflite::SVDFOptionsT *AsSVDFOptions() {
2019 return type == BuiltinOptions_SVDFOptions ?
2020 reinterpret_cast<tflite::SVDFOptionsT *>(value) : nullptr;
2021 }
2022 const tflite::SVDFOptionsT *AsSVDFOptions() const {
2023 return type == BuiltinOptions_SVDFOptions ?
2024 reinterpret_cast<const tflite::SVDFOptionsT *>(value) : nullptr;
2025 }
2026 tflite::RNNOptionsT *AsRNNOptions() {
2027 return type == BuiltinOptions_RNNOptions ?
2028 reinterpret_cast<tflite::RNNOptionsT *>(value) : nullptr;
2029 }
2030 const tflite::RNNOptionsT *AsRNNOptions() const {
2031 return type == BuiltinOptions_RNNOptions ?
2032 reinterpret_cast<const tflite::RNNOptionsT *>(value) : nullptr;
2033 }
2034 tflite::FullyConnectedOptionsT *AsFullyConnectedOptions() {
2035 return type == BuiltinOptions_FullyConnectedOptions ?
2036 reinterpret_cast<tflite::FullyConnectedOptionsT *>(value) : nullptr;
2037 }
2038 const tflite::FullyConnectedOptionsT *AsFullyConnectedOptions() const {
2039 return type == BuiltinOptions_FullyConnectedOptions ?
2040 reinterpret_cast<const tflite::FullyConnectedOptionsT *>(value) : nullptr;
2041 }
2042 tflite::SoftmaxOptionsT *AsSoftmaxOptions() {
2043 return type == BuiltinOptions_SoftmaxOptions ?
2044 reinterpret_cast<tflite::SoftmaxOptionsT *>(value) : nullptr;
2045 }
2046 const tflite::SoftmaxOptionsT *AsSoftmaxOptions() const {
2047 return type == BuiltinOptions_SoftmaxOptions ?
2048 reinterpret_cast<const tflite::SoftmaxOptionsT *>(value) : nullptr;
2049 }
2050 tflite::ConcatenationOptionsT *AsConcatenationOptions() {
2051 return type == BuiltinOptions_ConcatenationOptions ?
2052 reinterpret_cast<tflite::ConcatenationOptionsT *>(value) : nullptr;
2053 }
2054 const tflite::ConcatenationOptionsT *AsConcatenationOptions() const {
2055 return type == BuiltinOptions_ConcatenationOptions ?
2056 reinterpret_cast<const tflite::ConcatenationOptionsT *>(value) : nullptr;
2057 }
2058 tflite::AddOptionsT *AsAddOptions() {
2059 return type == BuiltinOptions_AddOptions ?
2060 reinterpret_cast<tflite::AddOptionsT *>(value) : nullptr;
2061 }
2062 const tflite::AddOptionsT *AsAddOptions() const {
2063 return type == BuiltinOptions_AddOptions ?
2064 reinterpret_cast<const tflite::AddOptionsT *>(value) : nullptr;
2065 }
2066 tflite::L2NormOptionsT *AsL2NormOptions() {
2067 return type == BuiltinOptions_L2NormOptions ?
2068 reinterpret_cast<tflite::L2NormOptionsT *>(value) : nullptr;
2069 }
2070 const tflite::L2NormOptionsT *AsL2NormOptions() const {
2071 return type == BuiltinOptions_L2NormOptions ?
2072 reinterpret_cast<const tflite::L2NormOptionsT *>(value) : nullptr;
2073 }
2074 tflite::LocalResponseNormalizationOptionsT *AsLocalResponseNormalizationOptions() {
2075 return type == BuiltinOptions_LocalResponseNormalizationOptions ?
2076 reinterpret_cast<tflite::LocalResponseNormalizationOptionsT *>(value) : nullptr;
2077 }
2078 const tflite::LocalResponseNormalizationOptionsT *AsLocalResponseNormalizationOptions() const {
2079 return type == BuiltinOptions_LocalResponseNormalizationOptions ?
2080 reinterpret_cast<const tflite::LocalResponseNormalizationOptionsT *>(value) : nullptr;
2081 }
2082 tflite::LSTMOptionsT *AsLSTMOptions() {
2083 return type == BuiltinOptions_LSTMOptions ?
2084 reinterpret_cast<tflite::LSTMOptionsT *>(value) : nullptr;
2085 }
2086 const tflite::LSTMOptionsT *AsLSTMOptions() const {
2087 return type == BuiltinOptions_LSTMOptions ?
2088 reinterpret_cast<const tflite::LSTMOptionsT *>(value) : nullptr;
2089 }
2090 tflite::ResizeBilinearOptionsT *AsResizeBilinearOptions() {
2091 return type == BuiltinOptions_ResizeBilinearOptions ?
2092 reinterpret_cast<tflite::ResizeBilinearOptionsT *>(value) : nullptr;
2093 }
2094 const tflite::ResizeBilinearOptionsT *AsResizeBilinearOptions() const {
2095 return type == BuiltinOptions_ResizeBilinearOptions ?
2096 reinterpret_cast<const tflite::ResizeBilinearOptionsT *>(value) : nullptr;
2097 }
2098 tflite::CallOptionsT *AsCallOptions() {
2099 return type == BuiltinOptions_CallOptions ?
2100 reinterpret_cast<tflite::CallOptionsT *>(value) : nullptr;
2101 }
2102 const tflite::CallOptionsT *AsCallOptions() const {
2103 return type == BuiltinOptions_CallOptions ?
2104 reinterpret_cast<const tflite::CallOptionsT *>(value) : nullptr;
2105 }
2106 tflite::ReshapeOptionsT *AsReshapeOptions() {
2107 return type == BuiltinOptions_ReshapeOptions ?
2108 reinterpret_cast<tflite::ReshapeOptionsT *>(value) : nullptr;
2109 }
2110 const tflite::ReshapeOptionsT *AsReshapeOptions() const {
2111 return type == BuiltinOptions_ReshapeOptions ?
2112 reinterpret_cast<const tflite::ReshapeOptionsT *>(value) : nullptr;
2113 }
2114 tflite::SkipGramOptionsT *AsSkipGramOptions() {
2115 return type == BuiltinOptions_SkipGramOptions ?
2116 reinterpret_cast<tflite::SkipGramOptionsT *>(value) : nullptr;
2117 }
2118 const tflite::SkipGramOptionsT *AsSkipGramOptions() const {
2119 return type == BuiltinOptions_SkipGramOptions ?
2120 reinterpret_cast<const tflite::SkipGramOptionsT *>(value) : nullptr;
2121 }
2122 tflite::SpaceToDepthOptionsT *AsSpaceToDepthOptions() {
2123 return type == BuiltinOptions_SpaceToDepthOptions ?
2124 reinterpret_cast<tflite::SpaceToDepthOptionsT *>(value) : nullptr;
2125 }
2126 const tflite::SpaceToDepthOptionsT *AsSpaceToDepthOptions() const {
2127 return type == BuiltinOptions_SpaceToDepthOptions ?
2128 reinterpret_cast<const tflite::SpaceToDepthOptionsT *>(value) : nullptr;
2129 }
2130 tflite::EmbeddingLookupSparseOptionsT *AsEmbeddingLookupSparseOptions() {
2131 return type == BuiltinOptions_EmbeddingLookupSparseOptions ?
2132 reinterpret_cast<tflite::EmbeddingLookupSparseOptionsT *>(value) : nullptr;
2133 }
2134 const tflite::EmbeddingLookupSparseOptionsT *AsEmbeddingLookupSparseOptions() const {
2135 return type == BuiltinOptions_EmbeddingLookupSparseOptions ?
2136 reinterpret_cast<const tflite::EmbeddingLookupSparseOptionsT *>(value) : nullptr;
2137 }
2138 tflite::MulOptionsT *AsMulOptions() {
2139 return type == BuiltinOptions_MulOptions ?
2140 reinterpret_cast<tflite::MulOptionsT *>(value) : nullptr;
2141 }
2142 const tflite::MulOptionsT *AsMulOptions() const {
2143 return type == BuiltinOptions_MulOptions ?
2144 reinterpret_cast<const tflite::MulOptionsT *>(value) : nullptr;
2145 }
2146 tflite::PadOptionsT *AsPadOptions() {
2147 return type == BuiltinOptions_PadOptions ?
2148 reinterpret_cast<tflite::PadOptionsT *>(value) : nullptr;
2149 }
2150 const tflite::PadOptionsT *AsPadOptions() const {
2151 return type == BuiltinOptions_PadOptions ?
2152 reinterpret_cast<const tflite::PadOptionsT *>(value) : nullptr;
2153 }
2154 tflite::GatherOptionsT *AsGatherOptions() {
2155 return type == BuiltinOptions_GatherOptions ?
2156 reinterpret_cast<tflite::GatherOptionsT *>(value) : nullptr;
2157 }
2158 const tflite::GatherOptionsT *AsGatherOptions() const {
2159 return type == BuiltinOptions_GatherOptions ?
2160 reinterpret_cast<const tflite::GatherOptionsT *>(value) : nullptr;
2161 }
2162 tflite::BatchToSpaceNDOptionsT *AsBatchToSpaceNDOptions() {
2163 return type == BuiltinOptions_BatchToSpaceNDOptions ?
2164 reinterpret_cast<tflite::BatchToSpaceNDOptionsT *>(value) : nullptr;
2165 }
2166 const tflite::BatchToSpaceNDOptionsT *AsBatchToSpaceNDOptions() const {
2167 return type == BuiltinOptions_BatchToSpaceNDOptions ?
2168 reinterpret_cast<const tflite::BatchToSpaceNDOptionsT *>(value) : nullptr;
2169 }
2170 tflite::SpaceToBatchNDOptionsT *AsSpaceToBatchNDOptions() {
2171 return type == BuiltinOptions_SpaceToBatchNDOptions ?
2172 reinterpret_cast<tflite::SpaceToBatchNDOptionsT *>(value) : nullptr;
2173 }
2174 const tflite::SpaceToBatchNDOptionsT *AsSpaceToBatchNDOptions() const {
2175 return type == BuiltinOptions_SpaceToBatchNDOptions ?
2176 reinterpret_cast<const tflite::SpaceToBatchNDOptionsT *>(value) : nullptr;
2177 }
2178 tflite::TransposeOptionsT *AsTransposeOptions() {
2179 return type == BuiltinOptions_TransposeOptions ?
2180 reinterpret_cast<tflite::TransposeOptionsT *>(value) : nullptr;
2181 }
2182 const tflite::TransposeOptionsT *AsTransposeOptions() const {
2183 return type == BuiltinOptions_TransposeOptions ?
2184 reinterpret_cast<const tflite::TransposeOptionsT *>(value) : nullptr;
2185 }
2186 tflite::ReducerOptionsT *AsReducerOptions() {
2187 return type == BuiltinOptions_ReducerOptions ?
2188 reinterpret_cast<tflite::ReducerOptionsT *>(value) : nullptr;
2189 }
2190 const tflite::ReducerOptionsT *AsReducerOptions() const {
2191 return type == BuiltinOptions_ReducerOptions ?
2192 reinterpret_cast<const tflite::ReducerOptionsT *>(value) : nullptr;
2193 }
2194 tflite::SubOptionsT *AsSubOptions() {
2195 return type == BuiltinOptions_SubOptions ?
2196 reinterpret_cast<tflite::SubOptionsT *>(value) : nullptr;
2197 }
2198 const tflite::SubOptionsT *AsSubOptions() const {
2199 return type == BuiltinOptions_SubOptions ?
2200 reinterpret_cast<const tflite::SubOptionsT *>(value) : nullptr;
2201 }
2202 tflite::DivOptionsT *AsDivOptions() {
2203 return type == BuiltinOptions_DivOptions ?
2204 reinterpret_cast<tflite::DivOptionsT *>(value) : nullptr;
2205 }
2206 const tflite::DivOptionsT *AsDivOptions() const {
2207 return type == BuiltinOptions_DivOptions ?
2208 reinterpret_cast<const tflite::DivOptionsT *>(value) : nullptr;
2209 }
2210 tflite::SqueezeOptionsT *AsSqueezeOptions() {
2211 return type == BuiltinOptions_SqueezeOptions ?
2212 reinterpret_cast<tflite::SqueezeOptionsT *>(value) : nullptr;
2213 }
2214 const tflite::SqueezeOptionsT *AsSqueezeOptions() const {
2215 return type == BuiltinOptions_SqueezeOptions ?
2216 reinterpret_cast<const tflite::SqueezeOptionsT *>(value) : nullptr;
2217 }
2218 tflite::SequenceRNNOptionsT *AsSequenceRNNOptions() {
2219 return type == BuiltinOptions_SequenceRNNOptions ?
2220 reinterpret_cast<tflite::SequenceRNNOptionsT *>(value) : nullptr;
2221 }
2222 const tflite::SequenceRNNOptionsT *AsSequenceRNNOptions() const {
2223 return type == BuiltinOptions_SequenceRNNOptions ?
2224 reinterpret_cast<const tflite::SequenceRNNOptionsT *>(value) : nullptr;
2225 }
2226 tflite::StridedSliceOptionsT *AsStridedSliceOptions() {
2227 return type == BuiltinOptions_StridedSliceOptions ?
2228 reinterpret_cast<tflite::StridedSliceOptionsT *>(value) : nullptr;
2229 }
2230 const tflite::StridedSliceOptionsT *AsStridedSliceOptions() const {
2231 return type == BuiltinOptions_StridedSliceOptions ?
2232 reinterpret_cast<const tflite::StridedSliceOptionsT *>(value) : nullptr;
2233 }
2234 tflite::ExpOptionsT *AsExpOptions() {
2235 return type == BuiltinOptions_ExpOptions ?
2236 reinterpret_cast<tflite::ExpOptionsT *>(value) : nullptr;
2237 }
2238 const tflite::ExpOptionsT *AsExpOptions() const {
2239 return type == BuiltinOptions_ExpOptions ?
2240 reinterpret_cast<const tflite::ExpOptionsT *>(value) : nullptr;
2241 }
2242 tflite::TopKV2OptionsT *AsTopKV2Options() {
2243 return type == BuiltinOptions_TopKV2Options ?
2244 reinterpret_cast<tflite::TopKV2OptionsT *>(value) : nullptr;
2245 }
2246 const tflite::TopKV2OptionsT *AsTopKV2Options() const {
2247 return type == BuiltinOptions_TopKV2Options ?
2248 reinterpret_cast<const tflite::TopKV2OptionsT *>(value) : nullptr;
2249 }
2250 tflite::SplitOptionsT *AsSplitOptions() {
2251 return type == BuiltinOptions_SplitOptions ?
2252 reinterpret_cast<tflite::SplitOptionsT *>(value) : nullptr;
2253 }
2254 const tflite::SplitOptionsT *AsSplitOptions() const {
2255 return type == BuiltinOptions_SplitOptions ?
2256 reinterpret_cast<const tflite::SplitOptionsT *>(value) : nullptr;
2257 }
2258 tflite::LogSoftmaxOptionsT *AsLogSoftmaxOptions() {
2259 return type == BuiltinOptions_LogSoftmaxOptions ?
2260 reinterpret_cast<tflite::LogSoftmaxOptionsT *>(value) : nullptr;
2261 }
2262 const tflite::LogSoftmaxOptionsT *AsLogSoftmaxOptions() const {
2263 return type == BuiltinOptions_LogSoftmaxOptions ?
2264 reinterpret_cast<const tflite::LogSoftmaxOptionsT *>(value) : nullptr;
2265 }
2266 tflite::CastOptionsT *AsCastOptions() {
2267 return type == BuiltinOptions_CastOptions ?
2268 reinterpret_cast<tflite::CastOptionsT *>(value) : nullptr;
2269 }
2270 const tflite::CastOptionsT *AsCastOptions() const {
2271 return type == BuiltinOptions_CastOptions ?
2272 reinterpret_cast<const tflite::CastOptionsT *>(value) : nullptr;
2273 }
2274 tflite::DequantizeOptionsT *AsDequantizeOptions() {
2275 return type == BuiltinOptions_DequantizeOptions ?
2276 reinterpret_cast<tflite::DequantizeOptionsT *>(value) : nullptr;
2277 }
2278 const tflite::DequantizeOptionsT *AsDequantizeOptions() const {
2279 return type == BuiltinOptions_DequantizeOptions ?
2280 reinterpret_cast<const tflite::DequantizeOptionsT *>(value) : nullptr;
2281 }
2282 tflite::MaximumMinimumOptionsT *AsMaximumMinimumOptions() {
2283 return type == BuiltinOptions_MaximumMinimumOptions ?
2284 reinterpret_cast<tflite::MaximumMinimumOptionsT *>(value) : nullptr;
2285 }
2286 const tflite::MaximumMinimumOptionsT *AsMaximumMinimumOptions() const {
2287 return type == BuiltinOptions_MaximumMinimumOptions ?
2288 reinterpret_cast<const tflite::MaximumMinimumOptionsT *>(value) : nullptr;
2289 }
2290 tflite::ArgMaxOptionsT *AsArgMaxOptions() {
2291 return type == BuiltinOptions_ArgMaxOptions ?
2292 reinterpret_cast<tflite::ArgMaxOptionsT *>(value) : nullptr;
2293 }
2294 const tflite::ArgMaxOptionsT *AsArgMaxOptions() const {
2295 return type == BuiltinOptions_ArgMaxOptions ?
2296 reinterpret_cast<const tflite::ArgMaxOptionsT *>(value) : nullptr;
2297 }
2298 tflite::LessOptionsT *AsLessOptions() {
2299 return type == BuiltinOptions_LessOptions ?
2300 reinterpret_cast<tflite::LessOptionsT *>(value) : nullptr;
2301 }
2302 const tflite::LessOptionsT *AsLessOptions() const {
2303 return type == BuiltinOptions_LessOptions ?
2304 reinterpret_cast<const tflite::LessOptionsT *>(value) : nullptr;
2305 }
2306 tflite::NegOptionsT *AsNegOptions() {
2307 return type == BuiltinOptions_NegOptions ?
2308 reinterpret_cast<tflite::NegOptionsT *>(value) : nullptr;
2309 }
2310 const tflite::NegOptionsT *AsNegOptions() const {
2311 return type == BuiltinOptions_NegOptions ?
2312 reinterpret_cast<const tflite::NegOptionsT *>(value) : nullptr;
2313 }
2314 tflite::PadV2OptionsT *AsPadV2Options() {
2315 return type == BuiltinOptions_PadV2Options ?
2316 reinterpret_cast<tflite::PadV2OptionsT *>(value) : nullptr;
2317 }
2318 const tflite::PadV2OptionsT *AsPadV2Options() const {
2319 return type == BuiltinOptions_PadV2Options ?
2320 reinterpret_cast<const tflite::PadV2OptionsT *>(value) : nullptr;
2321 }
2322 tflite::GreaterOptionsT *AsGreaterOptions() {
2323 return type == BuiltinOptions_GreaterOptions ?
2324 reinterpret_cast<tflite::GreaterOptionsT *>(value) : nullptr;
2325 }
2326 const tflite::GreaterOptionsT *AsGreaterOptions() const {
2327 return type == BuiltinOptions_GreaterOptions ?
2328 reinterpret_cast<const tflite::GreaterOptionsT *>(value) : nullptr;
2329 }
2330 tflite::GreaterEqualOptionsT *AsGreaterEqualOptions() {
2331 return type == BuiltinOptions_GreaterEqualOptions ?
2332 reinterpret_cast<tflite::GreaterEqualOptionsT *>(value) : nullptr;
2333 }
2334 const tflite::GreaterEqualOptionsT *AsGreaterEqualOptions() const {
2335 return type == BuiltinOptions_GreaterEqualOptions ?
2336 reinterpret_cast<const tflite::GreaterEqualOptionsT *>(value) : nullptr;
2337 }
2338 tflite::LessEqualOptionsT *AsLessEqualOptions() {
2339 return type == BuiltinOptions_LessEqualOptions ?
2340 reinterpret_cast<tflite::LessEqualOptionsT *>(value) : nullptr;
2341 }
2342 const tflite::LessEqualOptionsT *AsLessEqualOptions() const {
2343 return type == BuiltinOptions_LessEqualOptions ?
2344 reinterpret_cast<const tflite::LessEqualOptionsT *>(value) : nullptr;
2345 }
2346 tflite::SelectOptionsT *AsSelectOptions() {
2347 return type == BuiltinOptions_SelectOptions ?
2348 reinterpret_cast<tflite::SelectOptionsT *>(value) : nullptr;
2349 }
2350 const tflite::SelectOptionsT *AsSelectOptions() const {
2351 return type == BuiltinOptions_SelectOptions ?
2352 reinterpret_cast<const tflite::SelectOptionsT *>(value) : nullptr;
2353 }
2354 tflite::SliceOptionsT *AsSliceOptions() {
2355 return type == BuiltinOptions_SliceOptions ?
2356 reinterpret_cast<tflite::SliceOptionsT *>(value) : nullptr;
2357 }
2358 const tflite::SliceOptionsT *AsSliceOptions() const {
2359 return type == BuiltinOptions_SliceOptions ?
2360 reinterpret_cast<const tflite::SliceOptionsT *>(value) : nullptr;
2361 }
2362 tflite::TransposeConvOptionsT *AsTransposeConvOptions() {
2363 return type == BuiltinOptions_TransposeConvOptions ?
2364 reinterpret_cast<tflite::TransposeConvOptionsT *>(value) : nullptr;
2365 }
2366 const tflite::TransposeConvOptionsT *AsTransposeConvOptions() const {
2367 return type == BuiltinOptions_TransposeConvOptions ?
2368 reinterpret_cast<const tflite::TransposeConvOptionsT *>(value) : nullptr;
2369 }
2370 tflite::SparseToDenseOptionsT *AsSparseToDenseOptions() {
2371 return type == BuiltinOptions_SparseToDenseOptions ?
2372 reinterpret_cast<tflite::SparseToDenseOptionsT *>(value) : nullptr;
2373 }
2374 const tflite::SparseToDenseOptionsT *AsSparseToDenseOptions() const {
2375 return type == BuiltinOptions_SparseToDenseOptions ?
2376 reinterpret_cast<const tflite::SparseToDenseOptionsT *>(value) : nullptr;
2377 }
2378 tflite::TileOptionsT *AsTileOptions() {
2379 return type == BuiltinOptions_TileOptions ?
2380 reinterpret_cast<tflite::TileOptionsT *>(value) : nullptr;
2381 }
2382 const tflite::TileOptionsT *AsTileOptions() const {
2383 return type == BuiltinOptions_TileOptions ?
2384 reinterpret_cast<const tflite::TileOptionsT *>(value) : nullptr;
2385 }
2386 tflite::ExpandDimsOptionsT *AsExpandDimsOptions() {
2387 return type == BuiltinOptions_ExpandDimsOptions ?
2388 reinterpret_cast<tflite::ExpandDimsOptionsT *>(value) : nullptr;
2389 }
2390 const tflite::ExpandDimsOptionsT *AsExpandDimsOptions() const {
2391 return type == BuiltinOptions_ExpandDimsOptions ?
2392 reinterpret_cast<const tflite::ExpandDimsOptionsT *>(value) : nullptr;
2393 }
2394 tflite::EqualOptionsT *AsEqualOptions() {
2395 return type == BuiltinOptions_EqualOptions ?
2396 reinterpret_cast<tflite::EqualOptionsT *>(value) : nullptr;
2397 }
2398 const tflite::EqualOptionsT *AsEqualOptions() const {
2399 return type == BuiltinOptions_EqualOptions ?
2400 reinterpret_cast<const tflite::EqualOptionsT *>(value) : nullptr;
2401 }
2402 tflite::NotEqualOptionsT *AsNotEqualOptions() {
2403 return type == BuiltinOptions_NotEqualOptions ?
2404 reinterpret_cast<tflite::NotEqualOptionsT *>(value) : nullptr;
2405 }
2406 const tflite::NotEqualOptionsT *AsNotEqualOptions() const {
2407 return type == BuiltinOptions_NotEqualOptions ?
2408 reinterpret_cast<const tflite::NotEqualOptionsT *>(value) : nullptr;
2409 }
2410 tflite::ShapeOptionsT *AsShapeOptions() {
2411 return type == BuiltinOptions_ShapeOptions ?
2412 reinterpret_cast<tflite::ShapeOptionsT *>(value) : nullptr;
2413 }
2414 const tflite::ShapeOptionsT *AsShapeOptions() const {
2415 return type == BuiltinOptions_ShapeOptions ?
2416 reinterpret_cast<const tflite::ShapeOptionsT *>(value) : nullptr;
2417 }
2418 tflite::PowOptionsT *AsPowOptions() {
2419 return type == BuiltinOptions_PowOptions ?
2420 reinterpret_cast<tflite::PowOptionsT *>(value) : nullptr;
2421 }
2422 const tflite::PowOptionsT *AsPowOptions() const {
2423 return type == BuiltinOptions_PowOptions ?
2424 reinterpret_cast<const tflite::PowOptionsT *>(value) : nullptr;
2425 }
2426 tflite::ArgMinOptionsT *AsArgMinOptions() {
2427 return type == BuiltinOptions_ArgMinOptions ?
2428 reinterpret_cast<tflite::ArgMinOptionsT *>(value) : nullptr;
2429 }
2430 const tflite::ArgMinOptionsT *AsArgMinOptions() const {
2431 return type == BuiltinOptions_ArgMinOptions ?
2432 reinterpret_cast<const tflite::ArgMinOptionsT *>(value) : nullptr;
2433 }
2434 tflite::FakeQuantOptionsT *AsFakeQuantOptions() {
2435 return type == BuiltinOptions_FakeQuantOptions ?
2436 reinterpret_cast<tflite::FakeQuantOptionsT *>(value) : nullptr;
2437 }
2438 const tflite::FakeQuantOptionsT *AsFakeQuantOptions() const {
2439 return type == BuiltinOptions_FakeQuantOptions ?
2440 reinterpret_cast<const tflite::FakeQuantOptionsT *>(value) : nullptr;
2441 }
2442 tflite::PackOptionsT *AsPackOptions() {
2443 return type == BuiltinOptions_PackOptions ?
2444 reinterpret_cast<tflite::PackOptionsT *>(value) : nullptr;
2445 }
2446 const tflite::PackOptionsT *AsPackOptions() const {
2447 return type == BuiltinOptions_PackOptions ?
2448 reinterpret_cast<const tflite::PackOptionsT *>(value) : nullptr;
2449 }
2450 tflite::LogicalOrOptionsT *AsLogicalOrOptions() {
2451 return type == BuiltinOptions_LogicalOrOptions ?
2452 reinterpret_cast<tflite::LogicalOrOptionsT *>(value) : nullptr;
2453 }
2454 const tflite::LogicalOrOptionsT *AsLogicalOrOptions() const {
2455 return type == BuiltinOptions_LogicalOrOptions ?
2456 reinterpret_cast<const tflite::LogicalOrOptionsT *>(value) : nullptr;
2457 }
2458 tflite::OneHotOptionsT *AsOneHotOptions() {
2459 return type == BuiltinOptions_OneHotOptions ?
2460 reinterpret_cast<tflite::OneHotOptionsT *>(value) : nullptr;
2461 }
2462 const tflite::OneHotOptionsT *AsOneHotOptions() const {
2463 return type == BuiltinOptions_OneHotOptions ?
2464 reinterpret_cast<const tflite::OneHotOptionsT *>(value) : nullptr;
2465 }
2466 tflite::LogicalAndOptionsT *AsLogicalAndOptions() {
2467 return type == BuiltinOptions_LogicalAndOptions ?
2468 reinterpret_cast<tflite::LogicalAndOptionsT *>(value) : nullptr;
2469 }
2470 const tflite::LogicalAndOptionsT *AsLogicalAndOptions() const {
2471 return type == BuiltinOptions_LogicalAndOptions ?
2472 reinterpret_cast<const tflite::LogicalAndOptionsT *>(value) : nullptr;
2473 }
2474 tflite::LogicalNotOptionsT *AsLogicalNotOptions() {
2475 return type == BuiltinOptions_LogicalNotOptions ?
2476 reinterpret_cast<tflite::LogicalNotOptionsT *>(value) : nullptr;
2477 }
2478 const tflite::LogicalNotOptionsT *AsLogicalNotOptions() const {
2479 return type == BuiltinOptions_LogicalNotOptions ?
2480 reinterpret_cast<const tflite::LogicalNotOptionsT *>(value) : nullptr;
2481 }
2482 tflite::UnpackOptionsT *AsUnpackOptions() {
2483 return type == BuiltinOptions_UnpackOptions ?
2484 reinterpret_cast<tflite::UnpackOptionsT *>(value) : nullptr;
2485 }
2486 const tflite::UnpackOptionsT *AsUnpackOptions() const {
2487 return type == BuiltinOptions_UnpackOptions ?
2488 reinterpret_cast<const tflite::UnpackOptionsT *>(value) : nullptr;
2489 }
2490 tflite::FloorDivOptionsT *AsFloorDivOptions() {
2491 return type == BuiltinOptions_FloorDivOptions ?
2492 reinterpret_cast<tflite::FloorDivOptionsT *>(value) : nullptr;
2493 }
2494 const tflite::FloorDivOptionsT *AsFloorDivOptions() const {
2495 return type == BuiltinOptions_FloorDivOptions ?
2496 reinterpret_cast<const tflite::FloorDivOptionsT *>(value) : nullptr;
2497 }
2498 tflite::SquareOptionsT *AsSquareOptions() {
2499 return type == BuiltinOptions_SquareOptions ?
2500 reinterpret_cast<tflite::SquareOptionsT *>(value) : nullptr;
2501 }
2502 const tflite::SquareOptionsT *AsSquareOptions() const {
2503 return type == BuiltinOptions_SquareOptions ?
2504 reinterpret_cast<const tflite::SquareOptionsT *>(value) : nullptr;
2505 }
2506 tflite::ZerosLikeOptionsT *AsZerosLikeOptions() {
2507 return type == BuiltinOptions_ZerosLikeOptions ?
2508 reinterpret_cast<tflite::ZerosLikeOptionsT *>(value) : nullptr;
2509 }
2510 const tflite::ZerosLikeOptionsT *AsZerosLikeOptions() const {
2511 return type == BuiltinOptions_ZerosLikeOptions ?
2512 reinterpret_cast<const tflite::ZerosLikeOptionsT *>(value) : nullptr;
2513 }
2514 tflite::FillOptionsT *AsFillOptions() {
2515 return type == BuiltinOptions_FillOptions ?
2516 reinterpret_cast<tflite::FillOptionsT *>(value) : nullptr;
2517 }
2518 const tflite::FillOptionsT *AsFillOptions() const {
2519 return type == BuiltinOptions_FillOptions ?
2520 reinterpret_cast<const tflite::FillOptionsT *>(value) : nullptr;
2521 }
2522 tflite::BidirectionalSequenceLSTMOptionsT *AsBidirectionalSequenceLSTMOptions() {
2523 return type == BuiltinOptions_BidirectionalSequenceLSTMOptions ?
2524 reinterpret_cast<tflite::BidirectionalSequenceLSTMOptionsT *>(value) : nullptr;
2525 }
2526 const tflite::BidirectionalSequenceLSTMOptionsT *AsBidirectionalSequenceLSTMOptions() const {
2527 return type == BuiltinOptions_BidirectionalSequenceLSTMOptions ?
2528 reinterpret_cast<const tflite::BidirectionalSequenceLSTMOptionsT *>(value) : nullptr;
2529 }
2530 tflite::BidirectionalSequenceRNNOptionsT *AsBidirectionalSequenceRNNOptions() {
2531 return type == BuiltinOptions_BidirectionalSequenceRNNOptions ?
2532 reinterpret_cast<tflite::BidirectionalSequenceRNNOptionsT *>(value) : nullptr;
2533 }
2534 const tflite::BidirectionalSequenceRNNOptionsT *AsBidirectionalSequenceRNNOptions() const {
2535 return type == BuiltinOptions_BidirectionalSequenceRNNOptions ?
2536 reinterpret_cast<const tflite::BidirectionalSequenceRNNOptionsT *>(value) : nullptr;
2537 }
2538 tflite::UnidirectionalSequenceLSTMOptionsT *AsUnidirectionalSequenceLSTMOptions() {
2539 return type == BuiltinOptions_UnidirectionalSequenceLSTMOptions ?
2540 reinterpret_cast<tflite::UnidirectionalSequenceLSTMOptionsT *>(value) : nullptr;
2541 }
2542 const tflite::UnidirectionalSequenceLSTMOptionsT *AsUnidirectionalSequenceLSTMOptions() const {
2543 return type == BuiltinOptions_UnidirectionalSequenceLSTMOptions ?
2544 reinterpret_cast<const tflite::UnidirectionalSequenceLSTMOptionsT *>(value) : nullptr;
2545 }
2546 tflite::FloorModOptionsT *AsFloorModOptions() {
2547 return type == BuiltinOptions_FloorModOptions ?
2548 reinterpret_cast<tflite::FloorModOptionsT *>(value) : nullptr;
2549 }
2550 const tflite::FloorModOptionsT *AsFloorModOptions() const {
2551 return type == BuiltinOptions_FloorModOptions ?
2552 reinterpret_cast<const tflite::FloorModOptionsT *>(value) : nullptr;
2553 }
2554 tflite::RangeOptionsT *AsRangeOptions() {
2555 return type == BuiltinOptions_RangeOptions ?
2556 reinterpret_cast<tflite::RangeOptionsT *>(value) : nullptr;
2557 }
2558 const tflite::RangeOptionsT *AsRangeOptions() const {
2559 return type == BuiltinOptions_RangeOptions ?
2560 reinterpret_cast<const tflite::RangeOptionsT *>(value) : nullptr;
2561 }
2562 tflite::ResizeNearestNeighborOptionsT *AsResizeNearestNeighborOptions() {
2563 return type == BuiltinOptions_ResizeNearestNeighborOptions ?
2564 reinterpret_cast<tflite::ResizeNearestNeighborOptionsT *>(value) : nullptr;
2565 }
2566 const tflite::ResizeNearestNeighborOptionsT *AsResizeNearestNeighborOptions() const {
2567 return type == BuiltinOptions_ResizeNearestNeighborOptions ?
2568 reinterpret_cast<const tflite::ResizeNearestNeighborOptionsT *>(value) : nullptr;
2569 }
2570 tflite::LeakyReluOptionsT *AsLeakyReluOptions() {
2571 return type == BuiltinOptions_LeakyReluOptions ?
2572 reinterpret_cast<tflite::LeakyReluOptionsT *>(value) : nullptr;
2573 }
2574 const tflite::LeakyReluOptionsT *AsLeakyReluOptions() const {
2575 return type == BuiltinOptions_LeakyReluOptions ?
2576 reinterpret_cast<const tflite::LeakyReluOptionsT *>(value) : nullptr;
2577 }
2578 tflite::SquaredDifferenceOptionsT *AsSquaredDifferenceOptions() {
2579 return type == BuiltinOptions_SquaredDifferenceOptions ?
2580 reinterpret_cast<tflite::SquaredDifferenceOptionsT *>(value) : nullptr;
2581 }
2582 const tflite::SquaredDifferenceOptionsT *AsSquaredDifferenceOptions() const {
2583 return type == BuiltinOptions_SquaredDifferenceOptions ?
2584 reinterpret_cast<const tflite::SquaredDifferenceOptionsT *>(value) : nullptr;
2585 }
2586 tflite::MirrorPadOptionsT *AsMirrorPadOptions() {
2587 return type == BuiltinOptions_MirrorPadOptions ?
2588 reinterpret_cast<tflite::MirrorPadOptionsT *>(value) : nullptr;
2589 }
2590 const tflite::MirrorPadOptionsT *AsMirrorPadOptions() const {
2591 return type == BuiltinOptions_MirrorPadOptions ?
2592 reinterpret_cast<const tflite::MirrorPadOptionsT *>(value) : nullptr;
2593 }
2594 tflite::AbsOptionsT *AsAbsOptions() {
2595 return type == BuiltinOptions_AbsOptions ?
2596 reinterpret_cast<tflite::AbsOptionsT *>(value) : nullptr;
2597 }
2598 const tflite::AbsOptionsT *AsAbsOptions() const {
2599 return type == BuiltinOptions_AbsOptions ?
2600 reinterpret_cast<const tflite::AbsOptionsT *>(value) : nullptr;
2601 }
2602 tflite::SplitVOptionsT *AsSplitVOptions() {
2603 return type == BuiltinOptions_SplitVOptions ?
2604 reinterpret_cast<tflite::SplitVOptionsT *>(value) : nullptr;
2605 }
2606 const tflite::SplitVOptionsT *AsSplitVOptions() const {
2607 return type == BuiltinOptions_SplitVOptions ?
2608 reinterpret_cast<const tflite::SplitVOptionsT *>(value) : nullptr;
2609 }
2610 tflite::UniqueOptionsT *AsUniqueOptions() {
2611 return type == BuiltinOptions_UniqueOptions ?
2612 reinterpret_cast<tflite::UniqueOptionsT *>(value) : nullptr;
2613 }
2614 const tflite::UniqueOptionsT *AsUniqueOptions() const {
2615 return type == BuiltinOptions_UniqueOptions ?
2616 reinterpret_cast<const tflite::UniqueOptionsT *>(value) : nullptr;
2617 }
2618 tflite::ReverseV2OptionsT *AsReverseV2Options() {
2619 return type == BuiltinOptions_ReverseV2Options ?
2620 reinterpret_cast<tflite::ReverseV2OptionsT *>(value) : nullptr;
2621 }
2622 const tflite::ReverseV2OptionsT *AsReverseV2Options() const {
2623 return type == BuiltinOptions_ReverseV2Options ?
2624 reinterpret_cast<const tflite::ReverseV2OptionsT *>(value) : nullptr;
2625 }
2626 tflite::AddNOptionsT *AsAddNOptions() {
2627 return type == BuiltinOptions_AddNOptions ?
2628 reinterpret_cast<tflite::AddNOptionsT *>(value) : nullptr;
2629 }
2630 const tflite::AddNOptionsT *AsAddNOptions() const {
2631 return type == BuiltinOptions_AddNOptions ?
2632 reinterpret_cast<const tflite::AddNOptionsT *>(value) : nullptr;
2633 }
2634 tflite::GatherNdOptionsT *AsGatherNdOptions() {
2635 return type == BuiltinOptions_GatherNdOptions ?
2636 reinterpret_cast<tflite::GatherNdOptionsT *>(value) : nullptr;
2637 }
2638 const tflite::GatherNdOptionsT *AsGatherNdOptions() const {
2639 return type == BuiltinOptions_GatherNdOptions ?
2640 reinterpret_cast<const tflite::GatherNdOptionsT *>(value) : nullptr;
2641 }
2642 tflite::CosOptionsT *AsCosOptions() {
2643 return type == BuiltinOptions_CosOptions ?
2644 reinterpret_cast<tflite::CosOptionsT *>(value) : nullptr;
2645 }
2646 const tflite::CosOptionsT *AsCosOptions() const {
2647 return type == BuiltinOptions_CosOptions ?
2648 reinterpret_cast<const tflite::CosOptionsT *>(value) : nullptr;
2649 }
2650 tflite::WhereOptionsT *AsWhereOptions() {
2651 return type == BuiltinOptions_WhereOptions ?
2652 reinterpret_cast<tflite::WhereOptionsT *>(value) : nullptr;
2653 }
2654 const tflite::WhereOptionsT *AsWhereOptions() const {
2655 return type == BuiltinOptions_WhereOptions ?
2656 reinterpret_cast<const tflite::WhereOptionsT *>(value) : nullptr;
2657 }
2658 tflite::RankOptionsT *AsRankOptions() {
2659 return type == BuiltinOptions_RankOptions ?
2660 reinterpret_cast<tflite::RankOptionsT *>(value) : nullptr;
2661 }
2662 const tflite::RankOptionsT *AsRankOptions() const {
2663 return type == BuiltinOptions_RankOptions ?
2664 reinterpret_cast<const tflite::RankOptionsT *>(value) : nullptr;
2665 }
2666 tflite::ReverseSequenceOptionsT *AsReverseSequenceOptions() {
2667 return type == BuiltinOptions_ReverseSequenceOptions ?
2668 reinterpret_cast<tflite::ReverseSequenceOptionsT *>(value) : nullptr;
2669 }
2670 const tflite::ReverseSequenceOptionsT *AsReverseSequenceOptions() const {
2671 return type == BuiltinOptions_ReverseSequenceOptions ?
2672 reinterpret_cast<const tflite::ReverseSequenceOptionsT *>(value) : nullptr;
2673 }
2674 tflite::MatrixDiagOptionsT *AsMatrixDiagOptions() {
2675 return type == BuiltinOptions_MatrixDiagOptions ?
2676 reinterpret_cast<tflite::MatrixDiagOptionsT *>(value) : nullptr;
2677 }
2678 const tflite::MatrixDiagOptionsT *AsMatrixDiagOptions() const {
2679 return type == BuiltinOptions_MatrixDiagOptions ?
2680 reinterpret_cast<const tflite::MatrixDiagOptionsT *>(value) : nullptr;
2681 }
2682 tflite::QuantizeOptionsT *AsQuantizeOptions() {
2683 return type == BuiltinOptions_QuantizeOptions ?
2684 reinterpret_cast<tflite::QuantizeOptionsT *>(value) : nullptr;
2685 }
2686 const tflite::QuantizeOptionsT *AsQuantizeOptions() const {
2687 return type == BuiltinOptions_QuantizeOptions ?
2688 reinterpret_cast<const tflite::QuantizeOptionsT *>(value) : nullptr;
2689 }
2690 tflite::MatrixSetDiagOptionsT *AsMatrixSetDiagOptions() {
2691 return type == BuiltinOptions_MatrixSetDiagOptions ?
2692 reinterpret_cast<tflite::MatrixSetDiagOptionsT *>(value) : nullptr;
2693 }
2694 const tflite::MatrixSetDiagOptionsT *AsMatrixSetDiagOptions() const {
2695 return type == BuiltinOptions_MatrixSetDiagOptions ?
2696 reinterpret_cast<const tflite::MatrixSetDiagOptionsT *>(value) : nullptr;
2697 }
2698 tflite::HardSwishOptionsT *AsHardSwishOptions() {
2699 return type == BuiltinOptions_HardSwishOptions ?
2700 reinterpret_cast<tflite::HardSwishOptionsT *>(value) : nullptr;
2701 }
2702 const tflite::HardSwishOptionsT *AsHardSwishOptions() const {
2703 return type == BuiltinOptions_HardSwishOptions ?
2704 reinterpret_cast<const tflite::HardSwishOptionsT *>(value) : nullptr;
2705 }
2706 tflite::IfOptionsT *AsIfOptions() {
2707 return type == BuiltinOptions_IfOptions ?
2708 reinterpret_cast<tflite::IfOptionsT *>(value) : nullptr;
2709 }
2710 const tflite::IfOptionsT *AsIfOptions() const {
2711 return type == BuiltinOptions_IfOptions ?
2712 reinterpret_cast<const tflite::IfOptionsT *>(value) : nullptr;
2713 }
2714 tflite::WhileOptionsT *AsWhileOptions() {
2715 return type == BuiltinOptions_WhileOptions ?
2716 reinterpret_cast<tflite::WhileOptionsT *>(value) : nullptr;
2717 }
2718 const tflite::WhileOptionsT *AsWhileOptions() const {
2719 return type == BuiltinOptions_WhileOptions ?
2720 reinterpret_cast<const tflite::WhileOptionsT *>(value) : nullptr;
2721 }
2722 tflite::DepthToSpaceOptionsT *AsDepthToSpaceOptions() {
2723 return type == BuiltinOptions_DepthToSpaceOptions ?
2724 reinterpret_cast<tflite::DepthToSpaceOptionsT *>(value) : nullptr;
2725 }
2726 const tflite::DepthToSpaceOptionsT *AsDepthToSpaceOptions() const {
2727 return type == BuiltinOptions_DepthToSpaceOptions ?
2728 reinterpret_cast<const tflite::DepthToSpaceOptionsT *>(value) : nullptr;
2729 }
2730 tflite::NonMaxSuppressionV4OptionsT *AsNonMaxSuppressionV4Options() {
2731 return type == BuiltinOptions_NonMaxSuppressionV4Options ?
2732 reinterpret_cast<tflite::NonMaxSuppressionV4OptionsT *>(value) : nullptr;
2733 }
2734 const tflite::NonMaxSuppressionV4OptionsT *AsNonMaxSuppressionV4Options() const {
2735 return type == BuiltinOptions_NonMaxSuppressionV4Options ?
2736 reinterpret_cast<const tflite::NonMaxSuppressionV4OptionsT *>(value) : nullptr;
2737 }
2738 tflite::NonMaxSuppressionV5OptionsT *AsNonMaxSuppressionV5Options() {
2739 return type == BuiltinOptions_NonMaxSuppressionV5Options ?
2740 reinterpret_cast<tflite::NonMaxSuppressionV5OptionsT *>(value) : nullptr;
2741 }
2742 const tflite::NonMaxSuppressionV5OptionsT *AsNonMaxSuppressionV5Options() const {
2743 return type == BuiltinOptions_NonMaxSuppressionV5Options ?
2744 reinterpret_cast<const tflite::NonMaxSuppressionV5OptionsT *>(value) : nullptr;
2745 }
2746 tflite::ScatterNdOptionsT *AsScatterNdOptions() {
2747 return type == BuiltinOptions_ScatterNdOptions ?
2748 reinterpret_cast<tflite::ScatterNdOptionsT *>(value) : nullptr;
2749 }
2750 const tflite::ScatterNdOptionsT *AsScatterNdOptions() const {
2751 return type == BuiltinOptions_ScatterNdOptions ?
2752 reinterpret_cast<const tflite::ScatterNdOptionsT *>(value) : nullptr;
2753 }
2754 tflite::SelectV2OptionsT *AsSelectV2Options() {
2755 return type == BuiltinOptions_SelectV2Options ?
2756 reinterpret_cast<tflite::SelectV2OptionsT *>(value) : nullptr;
2757 }
2758 const tflite::SelectV2OptionsT *AsSelectV2Options() const {
2759 return type == BuiltinOptions_SelectV2Options ?
2760 reinterpret_cast<const tflite::SelectV2OptionsT *>(value) : nullptr;
2761 }
2762 tflite::DensifyOptionsT *AsDensifyOptions() {
2763 return type == BuiltinOptions_DensifyOptions ?
2764 reinterpret_cast<tflite::DensifyOptionsT *>(value) : nullptr;
2765 }
2766 const tflite::DensifyOptionsT *AsDensifyOptions() const {
2767 return type == BuiltinOptions_DensifyOptions ?
2768 reinterpret_cast<const tflite::DensifyOptionsT *>(value) : nullptr;
2769 }
2770 tflite::SegmentSumOptionsT *AsSegmentSumOptions() {
2771 return type == BuiltinOptions_SegmentSumOptions ?
2772 reinterpret_cast<tflite::SegmentSumOptionsT *>(value) : nullptr;
2773 }
2774 const tflite::SegmentSumOptionsT *AsSegmentSumOptions() const {
2775 return type == BuiltinOptions_SegmentSumOptions ?
2776 reinterpret_cast<const tflite::SegmentSumOptionsT *>(value) : nullptr;
2777 }
2778 tflite::BatchMatMulOptionsT *AsBatchMatMulOptions() {
2779 return type == BuiltinOptions_BatchMatMulOptions ?
2780 reinterpret_cast<tflite::BatchMatMulOptionsT *>(value) : nullptr;
2781 }
2782 const tflite::BatchMatMulOptionsT *AsBatchMatMulOptions() const {
2783 return type == BuiltinOptions_BatchMatMulOptions ?
2784 reinterpret_cast<const tflite::BatchMatMulOptionsT *>(value) : nullptr;
2785 }
2786 tflite::CumsumOptionsT *AsCumsumOptions() {
2787 return type == BuiltinOptions_CumsumOptions ?
2788 reinterpret_cast<tflite::CumsumOptionsT *>(value) : nullptr;
2789 }
2790 const tflite::CumsumOptionsT *AsCumsumOptions() const {
2791 return type == BuiltinOptions_CumsumOptions ?
2792 reinterpret_cast<const tflite::CumsumOptionsT *>(value) : nullptr;
2793 }
2794 tflite::CallOnceOptionsT *AsCallOnceOptions() {
2795 return type == BuiltinOptions_CallOnceOptions ?
2796 reinterpret_cast<tflite::CallOnceOptionsT *>(value) : nullptr;
2797 }
2798 const tflite::CallOnceOptionsT *AsCallOnceOptions() const {
2799 return type == BuiltinOptions_CallOnceOptions ?
2800 reinterpret_cast<const tflite::CallOnceOptionsT *>(value) : nullptr;
2801 }
2802 tflite::BroadcastToOptionsT *AsBroadcastToOptions() {
2803 return type == BuiltinOptions_BroadcastToOptions ?
2804 reinterpret_cast<tflite::BroadcastToOptionsT *>(value) : nullptr;
2805 }
2806 const tflite::BroadcastToOptionsT *AsBroadcastToOptions() const {
2807 return type == BuiltinOptions_BroadcastToOptions ?
2808 reinterpret_cast<const tflite::BroadcastToOptionsT *>(value) : nullptr;
2809 }
2810 tflite::Rfft2dOptionsT *AsRfft2dOptions() {
2811 return type == BuiltinOptions_Rfft2dOptions ?
2812 reinterpret_cast<tflite::Rfft2dOptionsT *>(value) : nullptr;
2813 }
2814 const tflite::Rfft2dOptionsT *AsRfft2dOptions() const {
2815 return type == BuiltinOptions_Rfft2dOptions ?
2816 reinterpret_cast<const tflite::Rfft2dOptionsT *>(value) : nullptr;
2817 }
2818 tflite::Conv3DOptionsT *AsConv3DOptions() {
2819 return type == BuiltinOptions_Conv3DOptions ?
2820 reinterpret_cast<tflite::Conv3DOptionsT *>(value) : nullptr;
2821 }
2822 const tflite::Conv3DOptionsT *AsConv3DOptions() const {
2823 return type == BuiltinOptions_Conv3DOptions ?
2824 reinterpret_cast<const tflite::Conv3DOptionsT *>(value) : nullptr;
2825 }
2826 tflite::HashtableOptionsT *AsHashtableOptions() {
2827 return type == BuiltinOptions_HashtableOptions ?
2828 reinterpret_cast<tflite::HashtableOptionsT *>(value) : nullptr;
2829 }
2830 const tflite::HashtableOptionsT *AsHashtableOptions() const {
2831 return type == BuiltinOptions_HashtableOptions ?
2832 reinterpret_cast<const tflite::HashtableOptionsT *>(value) : nullptr;
2833 }
2834 tflite::HashtableFindOptionsT *AsHashtableFindOptions() {
2835 return type == BuiltinOptions_HashtableFindOptions ?
2836 reinterpret_cast<tflite::HashtableFindOptionsT *>(value) : nullptr;
2837 }
2838 const tflite::HashtableFindOptionsT *AsHashtableFindOptions() const {
2839 return type == BuiltinOptions_HashtableFindOptions ?
2840 reinterpret_cast<const tflite::HashtableFindOptionsT *>(value) : nullptr;
2841 }
2842 tflite::HashtableImportOptionsT *AsHashtableImportOptions() {
2843 return type == BuiltinOptions_HashtableImportOptions ?
2844 reinterpret_cast<tflite::HashtableImportOptionsT *>(value) : nullptr;
2845 }
2846 const tflite::HashtableImportOptionsT *AsHashtableImportOptions() const {
2847 return type == BuiltinOptions_HashtableImportOptions ?
2848 reinterpret_cast<const tflite::HashtableImportOptionsT *>(value) : nullptr;
2849 }
2850 tflite::HashtableSizeOptionsT *AsHashtableSizeOptions() {
2851 return type == BuiltinOptions_HashtableSizeOptions ?
2852 reinterpret_cast<tflite::HashtableSizeOptionsT *>(value) : nullptr;
2853 }
2854 const tflite::HashtableSizeOptionsT *AsHashtableSizeOptions() const {
2855 return type == BuiltinOptions_HashtableSizeOptions ?
2856 reinterpret_cast<const tflite::HashtableSizeOptionsT *>(value) : nullptr;
2857 }
2858};
2859
2860bool VerifyBuiltinOptions(flatbuffers::Verifier &verifier, const void *obj, BuiltinOptions type);
2861bool VerifyBuiltinOptionsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
2862
2863enum Padding {
2864 Padding_SAME = 0,
2865 Padding_VALID = 1,
2866 Padding_MIN = Padding_SAME,
2867 Padding_MAX = Padding_VALID
2868};
2869
2870inline const Padding (&EnumValuesPadding())[2] {
2871 static const Padding values[] = {
2872 Padding_SAME,
2873 Padding_VALID
2874 };
2875 return values;
2876}
2877
2878inline const char * const *EnumNamesPadding() {
2879 static const char * const names[3] = {
2880 "SAME",
2881 "VALID",
2882 nullptr
2883 };
2884 return names;
2885}
2886
2887inline const char *EnumNamePadding(Padding e) {
2888 if (flatbuffers::IsOutRange(e, Padding_SAME, Padding_VALID)) return "";
2889 const size_t index = static_cast<size_t>(e);
2890 return EnumNamesPadding()[index];
2891}
2892
2893enum ActivationFunctionType {
2894 ActivationFunctionType_NONE = 0,
2895 ActivationFunctionType_RELU = 1,
2896 ActivationFunctionType_RELU_N1_TO_1 = 2,
2897 ActivationFunctionType_RELU6 = 3,
2898 ActivationFunctionType_TANH = 4,
2899 ActivationFunctionType_SIGN_BIT = 5,
2900 ActivationFunctionType_MIN = ActivationFunctionType_NONE,
2901 ActivationFunctionType_MAX = ActivationFunctionType_SIGN_BIT
2902};
2903
2904inline const ActivationFunctionType (&EnumValuesActivationFunctionType())[6] {
2905 static const ActivationFunctionType values[] = {
2906 ActivationFunctionType_NONE,
2907 ActivationFunctionType_RELU,
2908 ActivationFunctionType_RELU_N1_TO_1,
2909 ActivationFunctionType_RELU6,
2910 ActivationFunctionType_TANH,
2911 ActivationFunctionType_SIGN_BIT
2912 };
2913 return values;
2914}
2915
2916inline const char * const *EnumNamesActivationFunctionType() {
2917 static const char * const names[7] = {
2918 "NONE",
2919 "RELU",
2920 "RELU_N1_TO_1",
2921 "RELU6",
2922 "TANH",
2923 "SIGN_BIT",
2924 nullptr
2925 };
2926 return names;
2927}
2928
2929inline const char *EnumNameActivationFunctionType(ActivationFunctionType e) {
2930 if (flatbuffers::IsOutRange(e, ActivationFunctionType_NONE, ActivationFunctionType_SIGN_BIT)) return "";
2931 const size_t index = static_cast<size_t>(e);
2932 return EnumNamesActivationFunctionType()[index];
2933}
2934
2935enum LSHProjectionType {
2936 LSHProjectionType_UNKNOWN = 0,
2937 LSHProjectionType_SPARSE = 1,
2938 LSHProjectionType_DENSE = 2,
2939 LSHProjectionType_MIN = LSHProjectionType_UNKNOWN,
2940 LSHProjectionType_MAX = LSHProjectionType_DENSE
2941};
2942
2943inline const LSHProjectionType (&EnumValuesLSHProjectionType())[3] {
2944 static const LSHProjectionType values[] = {
2945 LSHProjectionType_UNKNOWN,
2946 LSHProjectionType_SPARSE,
2947 LSHProjectionType_DENSE
2948 };
2949 return values;
2950}
2951
2952inline const char * const *EnumNamesLSHProjectionType() {
2953 static const char * const names[4] = {
2954 "UNKNOWN",
2955 "SPARSE",
2956 "DENSE",
2957 nullptr
2958 };
2959 return names;
2960}
2961
2962inline const char *EnumNameLSHProjectionType(LSHProjectionType e) {
2963 if (flatbuffers::IsOutRange(e, LSHProjectionType_UNKNOWN, LSHProjectionType_DENSE)) return "";
2964 const size_t index = static_cast<size_t>(e);
2965 return EnumNamesLSHProjectionType()[index];
2966}
2967
2968enum FullyConnectedOptionsWeightsFormat {
2969 FullyConnectedOptionsWeightsFormat_DEFAULT = 0,
2970 FullyConnectedOptionsWeightsFormat_SHUFFLED4x16INT8 = 1,
2971 FullyConnectedOptionsWeightsFormat_MIN = FullyConnectedOptionsWeightsFormat_DEFAULT,
2972 FullyConnectedOptionsWeightsFormat_MAX = FullyConnectedOptionsWeightsFormat_SHUFFLED4x16INT8
2973};
2974
2975inline const FullyConnectedOptionsWeightsFormat (&EnumValuesFullyConnectedOptionsWeightsFormat())[2] {
2976 static const FullyConnectedOptionsWeightsFormat values[] = {
2977 FullyConnectedOptionsWeightsFormat_DEFAULT,
2978 FullyConnectedOptionsWeightsFormat_SHUFFLED4x16INT8
2979 };
2980 return values;
2981}
2982
2983inline const char * const *EnumNamesFullyConnectedOptionsWeightsFormat() {
2984 static const char * const names[3] = {
2985 "DEFAULT",
2986 "SHUFFLED4x16INT8",
2987 nullptr
2988 };
2989 return names;
2990}
2991
2992inline const char *EnumNameFullyConnectedOptionsWeightsFormat(FullyConnectedOptionsWeightsFormat e) {
2993 if (flatbuffers::IsOutRange(e, FullyConnectedOptionsWeightsFormat_DEFAULT, FullyConnectedOptionsWeightsFormat_SHUFFLED4x16INT8)) return "";
2994 const size_t index = static_cast<size_t>(e);
2995 return EnumNamesFullyConnectedOptionsWeightsFormat()[index];
2996}
2997
2998enum LSTMKernelType {
2999 LSTMKernelType_FULL = 0,
3000 LSTMKernelType_BASIC = 1,
3001 LSTMKernelType_MIN = LSTMKernelType_FULL,
3002 LSTMKernelType_MAX = LSTMKernelType_BASIC
3003};
3004
3005inline const LSTMKernelType (&EnumValuesLSTMKernelType())[2] {
3006 static const LSTMKernelType values[] = {
3007 LSTMKernelType_FULL,
3008 LSTMKernelType_BASIC
3009 };
3010 return values;
3011}
3012
3013inline const char * const *EnumNamesLSTMKernelType() {
3014 static const char * const names[3] = {
3015 "FULL",
3016 "BASIC",
3017 nullptr
3018 };
3019 return names;
3020}
3021
3022inline const char *EnumNameLSTMKernelType(LSTMKernelType e) {
3023 if (flatbuffers::IsOutRange(e, LSTMKernelType_FULL, LSTMKernelType_BASIC)) return "";
3024 const size_t index = static_cast<size_t>(e);
3025 return EnumNamesLSTMKernelType()[index];
3026}
3027
3028enum CombinerType {
3029 CombinerType_SUM = 0,
3030 CombinerType_MEAN = 1,
3031 CombinerType_SQRTN = 2,
3032 CombinerType_MIN = CombinerType_SUM,
3033 CombinerType_MAX = CombinerType_SQRTN
3034};
3035
3036inline const CombinerType (&EnumValuesCombinerType())[3] {
3037 static const CombinerType values[] = {
3038 CombinerType_SUM,
3039 CombinerType_MEAN,
3040 CombinerType_SQRTN
3041 };
3042 return values;
3043}
3044
3045inline const char * const *EnumNamesCombinerType() {
3046 static const char * const names[4] = {
3047 "SUM",
3048 "MEAN",
3049 "SQRTN",
3050 nullptr
3051 };
3052 return names;
3053}
3054
3055inline const char *EnumNameCombinerType(CombinerType e) {
3056 if (flatbuffers::IsOutRange(e, CombinerType_SUM, CombinerType_SQRTN)) return "";
3057 const size_t index = static_cast<size_t>(e);
3058 return EnumNamesCombinerType()[index];
3059}
3060
3061enum MirrorPadMode {
3062 MirrorPadMode_REFLECT = 0,
3063 MirrorPadMode_SYMMETRIC = 1,
3064 MirrorPadMode_MIN = MirrorPadMode_REFLECT,
3065 MirrorPadMode_MAX = MirrorPadMode_SYMMETRIC
3066};
3067
3068inline const MirrorPadMode (&EnumValuesMirrorPadMode())[2] {
3069 static const MirrorPadMode values[] = {
3070 MirrorPadMode_REFLECT,
3071 MirrorPadMode_SYMMETRIC
3072 };
3073 return values;
3074}
3075
3076inline const char * const *EnumNamesMirrorPadMode() {
3077 static const char * const names[3] = {
3078 "REFLECT",
3079 "SYMMETRIC",
3080 nullptr
3081 };
3082 return names;
3083}
3084
3085inline const char *EnumNameMirrorPadMode(MirrorPadMode e) {
3086 if (flatbuffers::IsOutRange(e, MirrorPadMode_REFLECT, MirrorPadMode_SYMMETRIC)) return "";
3087 const size_t index = static_cast<size_t>(e);
3088 return EnumNamesMirrorPadMode()[index];
3089}
3090
3091enum CustomOptionsFormat {
3092 CustomOptionsFormat_FLEXBUFFERS = 0,
3093 CustomOptionsFormat_MIN = CustomOptionsFormat_FLEXBUFFERS,
3094 CustomOptionsFormat_MAX = CustomOptionsFormat_FLEXBUFFERS
3095};
3096
3097inline const CustomOptionsFormat (&EnumValuesCustomOptionsFormat())[1] {
3098 static const CustomOptionsFormat values[] = {
3099 CustomOptionsFormat_FLEXBUFFERS
3100 };
3101 return values;
3102}
3103
3104inline const char * const *EnumNamesCustomOptionsFormat() {
3105 static const char * const names[2] = {
3106 "FLEXBUFFERS",
3107 nullptr
3108 };
3109 return names;
3110}
3111
3112inline const char *EnumNameCustomOptionsFormat(CustomOptionsFormat e) {
3113 if (flatbuffers::IsOutRange(e, CustomOptionsFormat_FLEXBUFFERS, CustomOptionsFormat_FLEXBUFFERS)) return "";
3114 const size_t index = static_cast<size_t>(e);
3115 return EnumNamesCustomOptionsFormat()[index];
3116}
3117
3118struct CustomQuantizationT : public flatbuffers::NativeTable {
3119 typedef CustomQuantization TableType;
3120 std::vector<uint8_t> custom;
3121 CustomQuantizationT() {
3122 }
3123};
3124
3125struct CustomQuantization FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3126 typedef CustomQuantizationT NativeTableType;
3127 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3128 VT_CUSTOM = 4
3129 };
3130 const flatbuffers::Vector<uint8_t> *custom() const {
3131 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_CUSTOM);
3132 }
3133 bool Verify(flatbuffers::Verifier &verifier) const {
3134 return VerifyTableStart(verifier) &&
3135 VerifyOffset(verifier, VT_CUSTOM) &&
3136 verifier.VerifyVector(custom()) &&
3137 verifier.EndTable();
3138 }
3139 CustomQuantizationT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
3140 void UnPackTo(CustomQuantizationT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
3141 static flatbuffers::Offset<CustomQuantization> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
3142};
3143
3144struct CustomQuantizationBuilder {
3145 flatbuffers::FlatBufferBuilder &fbb_;
3146 flatbuffers::uoffset_t start_;
3147 void add_custom(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom) {
3148 fbb_.AddOffset(CustomQuantization::VT_CUSTOM, custom);
3149 }
3150 explicit CustomQuantizationBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3151 : fbb_(_fbb) {
3152 start_ = fbb_.StartTable();
3153 }
3154 CustomQuantizationBuilder &operator=(const CustomQuantizationBuilder &);
3155 flatbuffers::Offset<CustomQuantization> Finish() {
3156 const auto end = fbb_.EndTable(start_);
3157 auto o = flatbuffers::Offset<CustomQuantization>(end);
3158 return o;
3159 }
3160};
3161
3162inline flatbuffers::Offset<CustomQuantization> CreateCustomQuantization(
3163 flatbuffers::FlatBufferBuilder &_fbb,
3164 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom = 0) {
3165 CustomQuantizationBuilder builder_(_fbb);
3166 builder_.add_custom(custom);
3167 return builder_.Finish();
3168}
3169
3170inline flatbuffers::Offset<CustomQuantization> CreateCustomQuantizationDirect(
3171 flatbuffers::FlatBufferBuilder &_fbb,
3172 const std::vector<uint8_t> *custom = nullptr) {
3173 if (custom) { _fbb.ForceVectorAlignment(custom->size(), sizeof(uint8_t), 16); }
3174 auto custom__ = custom ? _fbb.CreateVector<uint8_t>(*custom) : 0;
3175 return tflite::CreateCustomQuantization(
3176 _fbb,
3177 custom__);
3178}
3179
3180flatbuffers::Offset<CustomQuantization> CreateCustomQuantization(flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
3181
3182struct QuantizationParametersT : public flatbuffers::NativeTable {
3183 typedef QuantizationParameters TableType;
3184 std::vector<float> min;
3185 std::vector<float> max;
3186 std::vector<float> scale;
3187 std::vector<int64_t> zero_point;
3188 tflite::QuantizationDetailsUnion details;
3189 int32_t quantized_dimension;
3190 QuantizationParametersT()
3191 : quantized_dimension(0) {
3192 }
3193};
3194
3195struct QuantizationParameters FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3196 typedef QuantizationParametersT NativeTableType;
3197 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3198 VT_MIN = 4,
3199 VT_MAX = 6,
3200 VT_SCALE = 8,
3201 VT_ZERO_POINT = 10,
3202 VT_DETAILS_TYPE = 12,
3203 VT_DETAILS = 14,
3204 VT_QUANTIZED_DIMENSION = 16
3205 };
3206 const flatbuffers::Vector<float> *min() const {
3207 return GetPointer<const flatbuffers::Vector<float> *>(VT_MIN);
3208 }
3209 const flatbuffers::Vector<float> *max() const {
3210 return GetPointer<const flatbuffers::Vector<float> *>(VT_MAX);
3211 }
3212 const flatbuffers::Vector<float> *scale() const {
3213 return GetPointer<const flatbuffers::Vector<float> *>(VT_SCALE);
3214 }
3215 const flatbuffers::Vector<int64_t> *zero_point() const {
3216 return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_ZERO_POINT);
3217 }
3218 tflite::QuantizationDetails details_type() const {
3219 return static_cast<tflite::QuantizationDetails>(GetField<uint8_t>(VT_DETAILS_TYPE, 0));
3220 }
3221 const void *details() const {
3222 return GetPointer<const void *>(VT_DETAILS);
3223 }
3224 template<typename T> const T *details_as() const;
3225 const tflite::CustomQuantization *details_as_CustomQuantization() const {
3226 return details_type() == tflite::QuantizationDetails_CustomQuantization ? static_cast<const tflite::CustomQuantization *>(details()) : nullptr;
3227 }
3228 int32_t quantized_dimension() const {
3229 return GetField<int32_t>(VT_QUANTIZED_DIMENSION, 0);
3230 }
3231 bool Verify(flatbuffers::Verifier &verifier) const {
3232 return VerifyTableStart(verifier) &&
3233 VerifyOffset(verifier, VT_MIN) &&
3234 verifier.VerifyVector(min()) &&
3235 VerifyOffset(verifier, VT_MAX) &&
3236 verifier.VerifyVector(max()) &&
3237 VerifyOffset(verifier, VT_SCALE) &&
3238 verifier.VerifyVector(scale()) &&
3239 VerifyOffset(verifier, VT_ZERO_POINT) &&
3240 verifier.VerifyVector(zero_point()) &&
3241 VerifyField<uint8_t>(verifier, VT_DETAILS_TYPE) &&
3242 VerifyOffset(verifier, VT_DETAILS) &&
3243 VerifyQuantizationDetails(verifier, details(), details_type()) &&
3244 VerifyField<int32_t>(verifier, VT_QUANTIZED_DIMENSION) &&
3245 verifier.EndTable();
3246 }
3247 QuantizationParametersT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
3248 void UnPackTo(QuantizationParametersT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
3249 static flatbuffers::Offset<QuantizationParameters> Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
3250};
3251
3252template<> inline const tflite::CustomQuantization *QuantizationParameters::details_as<tflite::CustomQuantization>() const {
3253 return details_as_CustomQuantization();
3254}
3255
3256struct QuantizationParametersBuilder {
3257 flatbuffers::FlatBufferBuilder &fbb_;
3258 flatbuffers::uoffset_t start_;
3259 void add_min(flatbuffers::Offset<flatbuffers::Vector<float>> min) {
3260 fbb_.AddOffset(QuantizationParameters::VT_MIN, min);
3261 }
3262 void add_max(flatbuffers::Offset<flatbuffers::Vector<float>> max) {
3263 fbb_.AddOffset(QuantizationParameters::VT_MAX, max);
3264 }
3265 void add_scale(flatbuffers::Offset<flatbuffers::Vector<float>> scale) {
3266 fbb_.AddOffset(QuantizationParameters::VT_SCALE, scale);
3267 }
3268 void add_zero_point(flatbuffers::Offset<flatbuffers::Vector<int64_t>> zero_point) {
3269 fbb_.AddOffset(QuantizationParameters::VT_ZERO_POINT, zero_point);
3270 }
3271 void add_details_type(tflite::QuantizationDetails details_type) {
3272 fbb_.AddElement<uint8_t>(QuantizationParameters::VT_DETAILS_TYPE, static_cast<uint8_t>(details_type), 0);
3273 }
3274 void add_details(flatbuffers::Offset<void> details) {
3275 fbb_.AddOffset(QuantizationParameters::VT_DETAILS, details);
3276 }
3277 void add_quantized_dimension(int32_t quantized_dimension) {
3278 fbb_.AddElement<int32_t>(QuantizationParameters::VT_QUANTIZED_DIMENSION, quantized_dimension, 0);
3279 }
3280 explicit QuantizationParametersBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3281 : fbb_(_fbb) {
3282 start_ = fbb_.StartTable();
3283 }
3284 QuantizationParametersBuilder &operator=(const QuantizationParametersBuilder &);
3285 flatbuffers::Offset<QuantizationParameters> Finish() {
3286 const auto end = fbb_.EndTable(start_);
3287 auto o = flatbuffers::Offset<QuantizationParameters>(end);
3288 return o;
3289 }
3290};
3291
3292inline flatbuffers::Offset<QuantizationParameters> CreateQuantizationParameters(
3293 flatbuffers::FlatBufferBuilder &_fbb,
3294 flatbuffers::Offset<flatbuffers::Vector<float>> min = 0,
3295 flatbuffers::Offset<flatbuffers::Vector<float>> max = 0,
3296 flatbuffers::Offset<flatbuffers::Vector<float>> scale = 0,
3297 flatbuffers::Offset<flatbuffers::Vector<int64_t>> zero_point = 0,
3298 tflite::QuantizationDetails details_type = tflite::QuantizationDetails_NONE,
3299 flatbuffers::Offset<void> details = 0,
3300 int32_t quantized_dimension = 0) {
3301 QuantizationParametersBuilder builder_(_fbb);
3302 builder_.add_quantized_dimension(quantized_dimension);
3303 builder_.add_details(details);
3304 builder_.add_zero_point(zero_point);
3305 builder_.add_scale(scale);
3306 builder_.add_max(max);
3307 builder_.add_min(min);
3308 builder_.add_details_type(details_type);
3309 return builder_.Finish();
3310}
3311
3312inline flatbuffers::Offset<QuantizationParameters> CreateQuantizationParametersDirect(
3313 flatbuffers::FlatBufferBuilder &_fbb,
3314 const std::vector<float> *min = nullptr,
3315 const std::vector<float> *max = nullptr,
3316 const std::vector<float> *scale = nullptr,
3317 const std::vector<int64_t> *zero_point = nullptr,
3318 tflite::QuantizationDetails details_type = tflite::QuantizationDetails_NONE,
3319 flatbuffers::Offset<void> details = 0,
3320 int32_t quantized_dimension = 0) {
3321 auto min__ = min ? _fbb.CreateVector<float>(*min) : 0;
3322 auto max__ = max ? _fbb.CreateVector<float>(*max) : 0;
3323 auto scale__ = scale ? _fbb.CreateVector<float>(*scale) : 0;
3324 auto zero_point__ = zero_point ? _fbb.CreateVector<int64_t>(*zero_point) : 0;
3325 return tflite::CreateQuantizationParameters(
3326 _fbb,
3327 min__,
3328 max__,
3329 scale__,
3330 zero_point__,
3331 details_type,
3332 details,
3333 quantized_dimension);
3334}
3335
3336flatbuffers::Offset<QuantizationParameters> CreateQuantizationParameters(flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
3337
3338struct Int32VectorT : public flatbuffers::NativeTable {
3339 typedef Int32Vector TableType;
3340 std::vector<int32_t> values;
3341 Int32VectorT() {
3342 }
3343};
3344
3345struct Int32Vector FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3346 typedef Int32VectorT NativeTableType;
3347 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3348 VT_VALUES = 4
3349 };
3350 const flatbuffers::Vector<int32_t> *values() const {
3351 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_VALUES);
3352 }
3353 bool Verify(flatbuffers::Verifier &verifier) const {
3354 return VerifyTableStart(verifier) &&
3355 VerifyOffset(verifier, VT_VALUES) &&
3356 verifier.VerifyVector(values()) &&
3357 verifier.EndTable();
3358 }
3359 Int32VectorT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
3360 void UnPackTo(Int32VectorT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
3361 static flatbuffers::Offset<Int32Vector> Pack(flatbuffers::FlatBufferBuilder &_fbb, const Int32VectorT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
3362};
3363
3364struct Int32VectorBuilder {
3365 flatbuffers::FlatBufferBuilder &fbb_;
3366 flatbuffers::uoffset_t start_;
3367 void add_values(flatbuffers::Offset<flatbuffers::Vector<int32_t>> values) {
3368 fbb_.AddOffset(Int32Vector::VT_VALUES, values);
3369 }
3370 explicit Int32VectorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3371 : fbb_(_fbb) {
3372 start_ = fbb_.StartTable();
3373 }
3374 Int32VectorBuilder &operator=(const Int32VectorBuilder &);
3375 flatbuffers::Offset<Int32Vector> Finish() {
3376 const auto end = fbb_.EndTable(start_);
3377 auto o = flatbuffers::Offset<Int32Vector>(end);
3378 return o;
3379 }
3380};
3381
3382inline flatbuffers::Offset<Int32Vector> CreateInt32Vector(
3383 flatbuffers::FlatBufferBuilder &_fbb,
3384 flatbuffers::Offset<flatbuffers::Vector<int32_t>> values = 0) {
3385 Int32VectorBuilder builder_(_fbb);
3386 builder_.add_values(values);
3387 return builder_.Finish();
3388}
3389
3390inline flatbuffers::Offset<Int32Vector> CreateInt32VectorDirect(
3391 flatbuffers::FlatBufferBuilder &_fbb,
3392 const std::vector<int32_t> *values = nullptr) {
3393 auto values__ = values ? _fbb.CreateVector<int32_t>(*values) : 0;
3394 return tflite::CreateInt32Vector(
3395 _fbb,
3396 values__);
3397}
3398
3399flatbuffers::Offset<Int32Vector> CreateInt32Vector(flatbuffers::FlatBufferBuilder &_fbb, const Int32VectorT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
3400
3401struct Uint16VectorT : public flatbuffers::NativeTable {
3402 typedef Uint16Vector TableType;
3403 std::vector<uint16_t> values;
3404 Uint16VectorT() {
3405 }
3406};
3407
3408struct Uint16Vector FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3409 typedef Uint16VectorT NativeTableType;
3410 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3411 VT_VALUES = 4
3412 };
3413 const flatbuffers::Vector<uint16_t> *values() const {
3414 return GetPointer<const flatbuffers::Vector<uint16_t> *>(VT_VALUES);
3415 }
3416 bool Verify(flatbuffers::Verifier &verifier) const {
3417 return VerifyTableStart(verifier) &&
3418 VerifyOffset(verifier, VT_VALUES) &&
3419 verifier.VerifyVector(values()) &&
3420 verifier.EndTable();
3421 }
3422 Uint16VectorT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
3423 void UnPackTo(Uint16VectorT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
3424 static flatbuffers::Offset<Uint16Vector> Pack(flatbuffers::FlatBufferBuilder &_fbb, const Uint16VectorT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
3425};
3426
3427struct Uint16VectorBuilder {
3428 flatbuffers::FlatBufferBuilder &fbb_;
3429 flatbuffers::uoffset_t start_;
3430 void add_values(flatbuffers::Offset<flatbuffers::Vector<uint16_t>> values) {
3431 fbb_.AddOffset(Uint16Vector::VT_VALUES, values);
3432 }
3433 explicit Uint16VectorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3434 : fbb_(_fbb) {
3435 start_ = fbb_.StartTable();
3436 }
3437 Uint16VectorBuilder &operator=(const Uint16VectorBuilder &);
3438 flatbuffers::Offset<Uint16Vector> Finish() {
3439 const auto end = fbb_.EndTable(start_);
3440 auto o = flatbuffers::Offset<Uint16Vector>(end);
3441 return o;
3442 }
3443};
3444
3445inline flatbuffers::Offset<Uint16Vector> CreateUint16Vector(
3446 flatbuffers::FlatBufferBuilder &_fbb,
3447 flatbuffers::Offset<flatbuffers::Vector<uint16_t>> values = 0) {
3448 Uint16VectorBuilder builder_(_fbb);
3449 builder_.add_values(values);
3450 return builder_.Finish();
3451}
3452
3453inline flatbuffers::Offset<Uint16Vector> CreateUint16VectorDirect(
3454 flatbuffers::FlatBufferBuilder &_fbb,
3455 const std::vector<uint16_t> *values = nullptr) {
3456 if (values) { _fbb.ForceVectorAlignment(values->size(), sizeof(uint16_t), 4); }
3457 auto values__ = values ? _fbb.CreateVector<uint16_t>(*values) : 0;
3458 return tflite::CreateUint16Vector(
3459 _fbb,
3460 values__);
3461}
3462
3463flatbuffers::Offset<Uint16Vector> CreateUint16Vector(flatbuffers::FlatBufferBuilder &_fbb, const Uint16VectorT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
3464
3465struct Uint8VectorT : public flatbuffers::NativeTable {
3466 typedef Uint8Vector TableType;
3467 std::vector<uint8_t> values;
3468 Uint8VectorT() {
3469 }
3470};
3471
3472struct Uint8Vector FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3473 typedef Uint8VectorT NativeTableType;
3474 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3475 VT_VALUES = 4
3476 };
3477 const flatbuffers::Vector<uint8_t> *values() const {
3478 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_VALUES);
3479 }
3480 bool Verify(flatbuffers::Verifier &verifier) const {
3481 return VerifyTableStart(verifier) &&
3482 VerifyOffset(verifier, VT_VALUES) &&
3483 verifier.VerifyVector(values()) &&
3484 verifier.EndTable();
3485 }
3486 Uint8VectorT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
3487 void UnPackTo(Uint8VectorT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
3488 static flatbuffers::Offset<Uint8Vector> Pack(flatbuffers::FlatBufferBuilder &_fbb, const Uint8VectorT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
3489};
3490
3491struct Uint8VectorBuilder {
3492 flatbuffers::FlatBufferBuilder &fbb_;
3493 flatbuffers::uoffset_t start_;
3494 void add_values(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> values) {
3495 fbb_.AddOffset(Uint8Vector::VT_VALUES, values);
3496 }
3497 explicit Uint8VectorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3498 : fbb_(_fbb) {
3499 start_ = fbb_.StartTable();
3500 }
3501 Uint8VectorBuilder &operator=(const Uint8VectorBuilder &);
3502 flatbuffers::Offset<Uint8Vector> Finish() {
3503 const auto end = fbb_.EndTable(start_);
3504 auto o = flatbuffers::Offset<Uint8Vector>(end);
3505 return o;
3506 }
3507};
3508
3509inline flatbuffers::Offset<Uint8Vector> CreateUint8Vector(
3510 flatbuffers::FlatBufferBuilder &_fbb,
3511 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> values = 0) {
3512 Uint8VectorBuilder builder_(_fbb);
3513 builder_.add_values(values);
3514 return builder_.Finish();
3515}
3516
3517inline flatbuffers::Offset<Uint8Vector> CreateUint8VectorDirect(
3518 flatbuffers::FlatBufferBuilder &_fbb,
3519 const std::vector<uint8_t> *values = nullptr) {
3520 if (values) { _fbb.ForceVectorAlignment(values->size(), sizeof(uint8_t), 4); }
3521 auto values__ = values ? _fbb.CreateVector<uint8_t>(*values) : 0;
3522 return tflite::CreateUint8Vector(
3523 _fbb,
3524 values__);
3525}
3526
3527flatbuffers::Offset<Uint8Vector> CreateUint8Vector(flatbuffers::FlatBufferBuilder &_fbb, const Uint8VectorT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
3528
3529struct DimensionMetadataT : public flatbuffers::NativeTable {
3530 typedef DimensionMetadata TableType;
3531 tflite::DimensionType format;
3532 int32_t dense_size;
3533 tflite::SparseIndexVectorUnion array_segments;
3534 tflite::SparseIndexVectorUnion array_indices;
3535 DimensionMetadataT()
3536 : format(tflite::DimensionType_DENSE),
3537 dense_size(0) {
3538 }
3539};
3540
3541struct DimensionMetadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3542 typedef DimensionMetadataT NativeTableType;
3543 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3544 VT_FORMAT = 4,
3545 VT_DENSE_SIZE = 6,
3546 VT_ARRAY_SEGMENTS_TYPE = 8,
3547 VT_ARRAY_SEGMENTS = 10,
3548 VT_ARRAY_INDICES_TYPE = 12,
3549 VT_ARRAY_INDICES = 14
3550 };
3551 tflite::DimensionType format() const {
3552 return static_cast<tflite::DimensionType>(GetField<int8_t>(VT_FORMAT, 0));
3553 }
3554 int32_t dense_size() const {
3555 return GetField<int32_t>(VT_DENSE_SIZE, 0);
3556 }
3557 tflite::SparseIndexVector array_segments_type() const {
3558 return static_cast<tflite::SparseIndexVector>(GetField<uint8_t>(VT_ARRAY_SEGMENTS_TYPE, 0));
3559 }
3560 const void *array_segments() const {
3561 return GetPointer<const void *>(VT_ARRAY_SEGMENTS);
3562 }
3563 template<typename T> const T *array_segments_as() const;
3564 const tflite::Int32Vector *array_segments_as_Int32Vector() const {
3565 return array_segments_type() == tflite::SparseIndexVector_Int32Vector ? static_cast<const tflite::Int32Vector *>(array_segments()) : nullptr;
3566 }
3567 const tflite::Uint16Vector *array_segments_as_Uint16Vector() const {
3568 return array_segments_type() == tflite::SparseIndexVector_Uint16Vector ? static_cast<const tflite::Uint16Vector *>(array_segments()) : nullptr;
3569 }
3570 const tflite::Uint8Vector *array_segments_as_Uint8Vector() const {
3571 return array_segments_type() == tflite::SparseIndexVector_Uint8Vector ? static_cast<const tflite::Uint8Vector *>(array_segments()) : nullptr;
3572 }
3573 tflite::SparseIndexVector array_indices_type() const {
3574 return static_cast<tflite::SparseIndexVector>(GetField<uint8_t>(VT_ARRAY_INDICES_TYPE, 0));
3575 }
3576 const void *array_indices() const {
3577 return GetPointer<const void *>(VT_ARRAY_INDICES);
3578 }
3579 template<typename T> const T *array_indices_as() const;
3580 const tflite::Int32Vector *array_indices_as_Int32Vector() const {
3581 return array_indices_type() == tflite::SparseIndexVector_Int32Vector ? static_cast<const tflite::Int32Vector *>(array_indices()) : nullptr;
3582 }
3583 const tflite::Uint16Vector *array_indices_as_Uint16Vector() const {
3584 return array_indices_type() == tflite::SparseIndexVector_Uint16Vector ? static_cast<const tflite::Uint16Vector *>(array_indices()) : nullptr;
3585 }
3586 const tflite::Uint8Vector *array_indices_as_Uint8Vector() const {
3587 return array_indices_type() == tflite::SparseIndexVector_Uint8Vector ? static_cast<const tflite::Uint8Vector *>(array_indices()) : nullptr;
3588 }
3589 bool Verify(flatbuffers::Verifier &verifier) const {
3590 return VerifyTableStart(verifier) &&
3591 VerifyField<int8_t>(verifier, VT_FORMAT) &&
3592 VerifyField<int32_t>(verifier, VT_DENSE_SIZE) &&
3593 VerifyField<uint8_t>(verifier, VT_ARRAY_SEGMENTS_TYPE) &&
3594 VerifyOffset(verifier, VT_ARRAY_SEGMENTS) &&
3595 VerifySparseIndexVector(verifier, array_segments(), array_segments_type()) &&
3596 VerifyField<uint8_t>(verifier, VT_ARRAY_INDICES_TYPE) &&
3597 VerifyOffset(verifier, VT_ARRAY_INDICES) &&
3598 VerifySparseIndexVector(verifier, array_indices(), array_indices_type()) &&
3599 verifier.EndTable();
3600 }
3601 DimensionMetadataT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
3602 void UnPackTo(DimensionMetadataT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
3603 static flatbuffers::Offset<DimensionMetadata> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
3604};
3605
3606template<> inline const tflite::Int32Vector *DimensionMetadata::array_segments_as<tflite::Int32Vector>() const {
3607 return array_segments_as_Int32Vector();
3608}
3609
3610template<> inline const tflite::Uint16Vector *DimensionMetadata::array_segments_as<tflite::Uint16Vector>() const {
3611 return array_segments_as_Uint16Vector();
3612}
3613
3614template<> inline const tflite::Uint8Vector *DimensionMetadata::array_segments_as<tflite::Uint8Vector>() const {
3615 return array_segments_as_Uint8Vector();
3616}
3617
3618template<> inline const tflite::Int32Vector *DimensionMetadata::array_indices_as<tflite::Int32Vector>() const {
3619 return array_indices_as_Int32Vector();
3620}
3621
3622template<> inline const tflite::Uint16Vector *DimensionMetadata::array_indices_as<tflite::Uint16Vector>() const {
3623 return array_indices_as_Uint16Vector();
3624}
3625
3626template<> inline const tflite::Uint8Vector *DimensionMetadata::array_indices_as<tflite::Uint8Vector>() const {
3627 return array_indices_as_Uint8Vector();
3628}
3629
3630struct DimensionMetadataBuilder {
3631 flatbuffers::FlatBufferBuilder &fbb_;
3632 flatbuffers::uoffset_t start_;
3633 void add_format(tflite::DimensionType format) {
3634 fbb_.AddElement<int8_t>(DimensionMetadata::VT_FORMAT, static_cast<int8_t>(format), 0);
3635 }
3636 void add_dense_size(int32_t dense_size) {
3637 fbb_.AddElement<int32_t>(DimensionMetadata::VT_DENSE_SIZE, dense_size, 0);
3638 }
3639 void add_array_segments_type(tflite::SparseIndexVector array_segments_type) {
3640 fbb_.AddElement<uint8_t>(DimensionMetadata::VT_ARRAY_SEGMENTS_TYPE, static_cast<uint8_t>(array_segments_type), 0);
3641 }
3642 void add_array_segments(flatbuffers::Offset<void> array_segments) {
3643 fbb_.AddOffset(DimensionMetadata::VT_ARRAY_SEGMENTS, array_segments);
3644 }
3645 void add_array_indices_type(tflite::SparseIndexVector array_indices_type) {
3646 fbb_.AddElement<uint8_t>(DimensionMetadata::VT_ARRAY_INDICES_TYPE, static_cast<uint8_t>(array_indices_type), 0);
3647 }
3648 void add_array_indices(flatbuffers::Offset<void> array_indices) {
3649 fbb_.AddOffset(DimensionMetadata::VT_ARRAY_INDICES, array_indices);
3650 }
3651 explicit DimensionMetadataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3652 : fbb_(_fbb) {
3653 start_ = fbb_.StartTable();
3654 }
3655 DimensionMetadataBuilder &operator=(const DimensionMetadataBuilder &);
3656 flatbuffers::Offset<DimensionMetadata> Finish() {
3657 const auto end = fbb_.EndTable(start_);
3658 auto o = flatbuffers::Offset<DimensionMetadata>(end);
3659 return o;
3660 }
3661};
3662
3663inline flatbuffers::Offset<DimensionMetadata> CreateDimensionMetadata(
3664 flatbuffers::FlatBufferBuilder &_fbb,
3665 tflite::DimensionType format = tflite::DimensionType_DENSE,
3666 int32_t dense_size = 0,
3667 tflite::SparseIndexVector array_segments_type = tflite::SparseIndexVector_NONE,
3668 flatbuffers::Offset<void> array_segments = 0,
3669 tflite::SparseIndexVector array_indices_type = tflite::SparseIndexVector_NONE,
3670 flatbuffers::Offset<void> array_indices = 0) {
3671 DimensionMetadataBuilder builder_(_fbb);
3672 builder_.add_array_indices(array_indices);
3673 builder_.add_array_segments(array_segments);
3674 builder_.add_dense_size(dense_size);
3675 builder_.add_array_indices_type(array_indices_type);
3676 builder_.add_array_segments_type(array_segments_type);
3677 builder_.add_format(format);
3678 return builder_.Finish();
3679}
3680
3681flatbuffers::Offset<DimensionMetadata> CreateDimensionMetadata(flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
3682
3683struct SparsityParametersT : public flatbuffers::NativeTable {
3684 typedef SparsityParameters TableType;
3685 std::vector<int32_t> traversal_order;
3686 std::vector<int32_t> block_map;
3687 std::vector<std::unique_ptr<tflite::DimensionMetadataT>> dim_metadata;
3688 SparsityParametersT() {
3689 }
3690};
3691
3692struct SparsityParameters FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3693 typedef SparsityParametersT NativeTableType;
3694 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3695 VT_TRAVERSAL_ORDER = 4,
3696 VT_BLOCK_MAP = 6,
3697 VT_DIM_METADATA = 8
3698 };
3699 const flatbuffers::Vector<int32_t> *traversal_order() const {
3700 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_TRAVERSAL_ORDER);
3701 }
3702 const flatbuffers::Vector<int32_t> *block_map() const {
3703 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_BLOCK_MAP);
3704 }
3705 const flatbuffers::Vector<flatbuffers::Offset<tflite::DimensionMetadata>> *dim_metadata() const {
3706 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::DimensionMetadata>> *>(VT_DIM_METADATA);
3707 }
3708 bool Verify(flatbuffers::Verifier &verifier) const {
3709 return VerifyTableStart(verifier) &&
3710 VerifyOffset(verifier, VT_TRAVERSAL_ORDER) &&
3711 verifier.VerifyVector(traversal_order()) &&
3712 VerifyOffset(verifier, VT_BLOCK_MAP) &&
3713 verifier.VerifyVector(block_map()) &&
3714 VerifyOffset(verifier, VT_DIM_METADATA) &&
3715 verifier.VerifyVector(dim_metadata()) &&
3716 verifier.VerifyVectorOfTables(dim_metadata()) &&
3717 verifier.EndTable();
3718 }
3719 SparsityParametersT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
3720 void UnPackTo(SparsityParametersT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
3721 static flatbuffers::Offset<SparsityParameters> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SparsityParametersT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
3722};
3723
3724struct SparsityParametersBuilder {
3725 flatbuffers::FlatBufferBuilder &fbb_;
3726 flatbuffers::uoffset_t start_;
3727 void add_traversal_order(flatbuffers::Offset<flatbuffers::Vector<int32_t>> traversal_order) {
3728 fbb_.AddOffset(SparsityParameters::VT_TRAVERSAL_ORDER, traversal_order);
3729 }
3730 void add_block_map(flatbuffers::Offset<flatbuffers::Vector<int32_t>> block_map) {
3731 fbb_.AddOffset(SparsityParameters::VT_BLOCK_MAP, block_map);
3732 }
3733 void add_dim_metadata(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::DimensionMetadata>>> dim_metadata) {
3734 fbb_.AddOffset(SparsityParameters::VT_DIM_METADATA, dim_metadata);
3735 }
3736 explicit SparsityParametersBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3737 : fbb_(_fbb) {
3738 start_ = fbb_.StartTable();
3739 }
3740 SparsityParametersBuilder &operator=(const SparsityParametersBuilder &);
3741 flatbuffers::Offset<SparsityParameters> Finish() {
3742 const auto end = fbb_.EndTable(start_);
3743 auto o = flatbuffers::Offset<SparsityParameters>(end);
3744 return o;
3745 }
3746};
3747
3748inline flatbuffers::Offset<SparsityParameters> CreateSparsityParameters(
3749 flatbuffers::FlatBufferBuilder &_fbb,
3750 flatbuffers::Offset<flatbuffers::Vector<int32_t>> traversal_order = 0,
3751 flatbuffers::Offset<flatbuffers::Vector<int32_t>> block_map = 0,
3752 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::DimensionMetadata>>> dim_metadata = 0) {
3753 SparsityParametersBuilder builder_(_fbb);
3754 builder_.add_dim_metadata(dim_metadata);
3755 builder_.add_block_map(block_map);
3756 builder_.add_traversal_order(traversal_order);
3757 return builder_.Finish();
3758}
3759
3760inline flatbuffers::Offset<SparsityParameters> CreateSparsityParametersDirect(
3761 flatbuffers::FlatBufferBuilder &_fbb,
3762 const std::vector<int32_t> *traversal_order = nullptr,
3763 const std::vector<int32_t> *block_map = nullptr,
3764 const std::vector<flatbuffers::Offset<tflite::DimensionMetadata>> *dim_metadata = nullptr) {
3765 auto traversal_order__ = traversal_order ? _fbb.CreateVector<int32_t>(*traversal_order) : 0;
3766 auto block_map__ = block_map ? _fbb.CreateVector<int32_t>(*block_map) : 0;
3767 auto dim_metadata__ = dim_metadata ? _fbb.CreateVector<flatbuffers::Offset<tflite::DimensionMetadata>>(*dim_metadata) : 0;
3768 return tflite::CreateSparsityParameters(
3769 _fbb,
3770 traversal_order__,
3771 block_map__,
3772 dim_metadata__);
3773}
3774
3775flatbuffers::Offset<SparsityParameters> CreateSparsityParameters(flatbuffers::FlatBufferBuilder &_fbb, const SparsityParametersT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
3776
3777struct TensorT : public flatbuffers::NativeTable {
3778 typedef Tensor TableType;
3779 std::vector<int32_t> shape;
3780 tflite::TensorType type;
3781 uint32_t buffer;
3782 std::string name;
3783 std::unique_ptr<tflite::QuantizationParametersT> quantization;
3784 bool is_variable;
3785 std::unique_ptr<tflite::SparsityParametersT> sparsity;
3786 std::vector<int32_t> shape_signature;
3787 TensorT()
3788 : type(tflite::TensorType_FLOAT32),
3789 buffer(0),
3790 is_variable(false) {
3791 }
3792};
3793
3794struct Tensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3795 typedef TensorT NativeTableType;
3796 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3797 VT_SHAPE = 4,
3798 VT_TYPE = 6,
3799 VT_BUFFER = 8,
3800 VT_NAME = 10,
3801 VT_QUANTIZATION = 12,
3802 VT_IS_VARIABLE = 14,
3803 VT_SPARSITY = 16,
3804 VT_SHAPE_SIGNATURE = 18
3805 };
3806 const flatbuffers::Vector<int32_t> *shape() const {
3807 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SHAPE);
3808 }
3809 tflite::TensorType type() const {
3810 return static_cast<tflite::TensorType>(GetField<int8_t>(VT_TYPE, 0));
3811 }
3812 uint32_t buffer() const {
3813 return GetField<uint32_t>(VT_BUFFER, 0);
3814 }
3815 const flatbuffers::String *name() const {
3816 return GetPointer<const flatbuffers::String *>(VT_NAME);
3817 }
3818 const tflite::QuantizationParameters *quantization() const {
3819 return GetPointer<const tflite::QuantizationParameters *>(VT_QUANTIZATION);
3820 }
3821 bool is_variable() const {
3822 return GetField<uint8_t>(VT_IS_VARIABLE, 0) != 0;
3823 }
3824 const tflite::SparsityParameters *sparsity() const {
3825 return GetPointer<const tflite::SparsityParameters *>(VT_SPARSITY);
3826 }
3827 const flatbuffers::Vector<int32_t> *shape_signature() const {
3828 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SHAPE_SIGNATURE);
3829 }
3830 bool Verify(flatbuffers::Verifier &verifier) const {
3831 return VerifyTableStart(verifier) &&
3832 VerifyOffset(verifier, VT_SHAPE) &&
3833 verifier.VerifyVector(shape()) &&
3834 VerifyField<int8_t>(verifier, VT_TYPE) &&
3835 VerifyField<uint32_t>(verifier, VT_BUFFER) &&
3836 VerifyOffset(verifier, VT_NAME) &&
3837 verifier.VerifyString(name()) &&
3838 VerifyOffset(verifier, VT_QUANTIZATION) &&
3839 verifier.VerifyTable(quantization()) &&
3840 VerifyField<uint8_t>(verifier, VT_IS_VARIABLE) &&
3841 VerifyOffset(verifier, VT_SPARSITY) &&
3842 verifier.VerifyTable(sparsity()) &&
3843 VerifyOffset(verifier, VT_SHAPE_SIGNATURE) &&
3844 verifier.VerifyVector(shape_signature()) &&
3845 verifier.EndTable();
3846 }
3847 TensorT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
3848 void UnPackTo(TensorT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
3849 static flatbuffers::Offset<Tensor> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
3850};
3851
3852struct TensorBuilder {
3853 flatbuffers::FlatBufferBuilder &fbb_;
3854 flatbuffers::uoffset_t start_;
3855 void add_shape(flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape) {
3856 fbb_.AddOffset(Tensor::VT_SHAPE, shape);
3857 }
3858 void add_type(tflite::TensorType type) {
3859 fbb_.AddElement<int8_t>(Tensor::VT_TYPE, static_cast<int8_t>(type), 0);
3860 }
3861 void add_buffer(uint32_t buffer) {
3862 fbb_.AddElement<uint32_t>(Tensor::VT_BUFFER, buffer, 0);
3863 }
3864 void add_name(flatbuffers::Offset<flatbuffers::String> name) {
3865 fbb_.AddOffset(Tensor::VT_NAME, name);
3866 }
3867 void add_quantization(flatbuffers::Offset<tflite::QuantizationParameters> quantization) {
3868 fbb_.AddOffset(Tensor::VT_QUANTIZATION, quantization);
3869 }
3870 void add_is_variable(bool is_variable) {
3871 fbb_.AddElement<uint8_t>(Tensor::VT_IS_VARIABLE, static_cast<uint8_t>(is_variable), 0);
3872 }
3873 void add_sparsity(flatbuffers::Offset<tflite::SparsityParameters> sparsity) {
3874 fbb_.AddOffset(Tensor::VT_SPARSITY, sparsity);
3875 }
3876 void add_shape_signature(flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape_signature) {
3877 fbb_.AddOffset(Tensor::VT_SHAPE_SIGNATURE, shape_signature);
3878 }
3879 explicit TensorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3880 : fbb_(_fbb) {
3881 start_ = fbb_.StartTable();
3882 }
3883 TensorBuilder &operator=(const TensorBuilder &);
3884 flatbuffers::Offset<Tensor> Finish() {
3885 const auto end = fbb_.EndTable(start_);
3886 auto o = flatbuffers::Offset<Tensor>(end);
3887 return o;
3888 }
3889};
3890
3891inline flatbuffers::Offset<Tensor> CreateTensor(
3892 flatbuffers::FlatBufferBuilder &_fbb,
3893 flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape = 0,
3894 tflite::TensorType type = tflite::TensorType_FLOAT32,
3895 uint32_t buffer = 0,
3896 flatbuffers::Offset<flatbuffers::String> name = 0,
3897 flatbuffers::Offset<tflite::QuantizationParameters> quantization = 0,
3898 bool is_variable = false,
3899 flatbuffers::Offset<tflite::SparsityParameters> sparsity = 0,
3900 flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape_signature = 0) {
3901 TensorBuilder builder_(_fbb);
3902 builder_.add_shape_signature(shape_signature);
3903 builder_.add_sparsity(sparsity);
3904 builder_.add_quantization(quantization);
3905 builder_.add_name(name);
3906 builder_.add_buffer(buffer);
3907 builder_.add_shape(shape);
3908 builder_.add_is_variable(is_variable);
3909 builder_.add_type(type);
3910 return builder_.Finish();
3911}
3912
3913inline flatbuffers::Offset<Tensor> CreateTensorDirect(
3914 flatbuffers::FlatBufferBuilder &_fbb,
3915 const std::vector<int32_t> *shape = nullptr,
3916 tflite::TensorType type = tflite::TensorType_FLOAT32,
3917 uint32_t buffer = 0,
3918 const char *name = nullptr,
3919 flatbuffers::Offset<tflite::QuantizationParameters> quantization = 0,
3920 bool is_variable = false,
3921 flatbuffers::Offset<tflite::SparsityParameters> sparsity = 0,
3922 const std::vector<int32_t> *shape_signature = nullptr) {
3923 auto shape__ = shape ? _fbb.CreateVector<int32_t>(*shape) : 0;
3924 auto name__ = name ? _fbb.CreateString(name) : 0;
3925 auto shape_signature__ = shape_signature ? _fbb.CreateVector<int32_t>(*shape_signature) : 0;
3926 return tflite::CreateTensor(
3927 _fbb,
3928 shape__,
3929 type,
3930 buffer,
3931 name__,
3932 quantization,
3933 is_variable,
3934 sparsity,
3935 shape_signature__);
3936}
3937
3938flatbuffers::Offset<Tensor> CreateTensor(flatbuffers::FlatBufferBuilder &_fbb, const TensorT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
3939
3940struct Conv2DOptionsT : public flatbuffers::NativeTable {
3941 typedef Conv2DOptions TableType;
3942 tflite::Padding padding;
3943 int32_t stride_w;
3944 int32_t stride_h;
3945 tflite::ActivationFunctionType fused_activation_function;
3946 int32_t dilation_w_factor;
3947 int32_t dilation_h_factor;
3948 Conv2DOptionsT()
3949 : padding(tflite::Padding_SAME),
3950 stride_w(0),
3951 stride_h(0),
3952 fused_activation_function(tflite::ActivationFunctionType_NONE),
3953 dilation_w_factor(1),
3954 dilation_h_factor(1) {
3955 }
3956};
3957
3958struct Conv2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3959 typedef Conv2DOptionsT NativeTableType;
3960 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3961 VT_PADDING = 4,
3962 VT_STRIDE_W = 6,
3963 VT_STRIDE_H = 8,
3964 VT_FUSED_ACTIVATION_FUNCTION = 10,
3965 VT_DILATION_W_FACTOR = 12,
3966 VT_DILATION_H_FACTOR = 14
3967 };
3968 tflite::Padding padding() const {
3969 return static_cast<tflite::Padding>(GetField<int8_t>(VT_PADDING, 0));
3970 }
3971 int32_t stride_w() const {
3972 return GetField<int32_t>(VT_STRIDE_W, 0);
3973 }
3974 int32_t stride_h() const {
3975 return GetField<int32_t>(VT_STRIDE_H, 0);
3976 }
3977 tflite::ActivationFunctionType fused_activation_function() const {
3978 return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
3979 }
3980 int32_t dilation_w_factor() const {
3981 return GetField<int32_t>(VT_DILATION_W_FACTOR, 1);
3982 }
3983 int32_t dilation_h_factor() const {
3984 return GetField<int32_t>(VT_DILATION_H_FACTOR, 1);
3985 }
3986 bool Verify(flatbuffers::Verifier &verifier) const {
3987 return VerifyTableStart(verifier) &&
3988 VerifyField<int8_t>(verifier, VT_PADDING) &&
3989 VerifyField<int32_t>(verifier, VT_STRIDE_W) &&
3990 VerifyField<int32_t>(verifier, VT_STRIDE_H) &&
3991 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
3992 VerifyField<int32_t>(verifier, VT_DILATION_W_FACTOR) &&
3993 VerifyField<int32_t>(verifier, VT_DILATION_H_FACTOR) &&
3994 verifier.EndTable();
3995 }
3996 Conv2DOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
3997 void UnPackTo(Conv2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
3998 static flatbuffers::Offset<Conv2DOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
3999};
4000
4001struct Conv2DOptionsBuilder {
4002 flatbuffers::FlatBufferBuilder &fbb_;
4003 flatbuffers::uoffset_t start_;
4004 void add_padding(tflite::Padding padding) {
4005 fbb_.AddElement<int8_t>(Conv2DOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
4006 }
4007 void add_stride_w(int32_t stride_w) {
4008 fbb_.AddElement<int32_t>(Conv2DOptions::VT_STRIDE_W, stride_w, 0);
4009 }
4010 void add_stride_h(int32_t stride_h) {
4011 fbb_.AddElement<int32_t>(Conv2DOptions::VT_STRIDE_H, stride_h, 0);
4012 }
4013 void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
4014 fbb_.AddElement<int8_t>(Conv2DOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
4015 }
4016 void add_dilation_w_factor(int32_t dilation_w_factor) {
4017 fbb_.AddElement<int32_t>(Conv2DOptions::VT_DILATION_W_FACTOR, dilation_w_factor, 1);
4018 }
4019 void add_dilation_h_factor(int32_t dilation_h_factor) {
4020 fbb_.AddElement<int32_t>(Conv2DOptions::VT_DILATION_H_FACTOR, dilation_h_factor, 1);
4021 }
4022 explicit Conv2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4023 : fbb_(_fbb) {
4024 start_ = fbb_.StartTable();
4025 }
4026 Conv2DOptionsBuilder &operator=(const Conv2DOptionsBuilder &);
4027 flatbuffers::Offset<Conv2DOptions> Finish() {
4028 const auto end = fbb_.EndTable(start_);
4029 auto o = flatbuffers::Offset<Conv2DOptions>(end);
4030 return o;
4031 }
4032};
4033
4034inline flatbuffers::Offset<Conv2DOptions> CreateConv2DOptions(
4035 flatbuffers::FlatBufferBuilder &_fbb,
4036 tflite::Padding padding = tflite::Padding_SAME,
4037 int32_t stride_w = 0,
4038 int32_t stride_h = 0,
4039 tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
4040 int32_t dilation_w_factor = 1,
4041 int32_t dilation_h_factor = 1) {
4042 Conv2DOptionsBuilder builder_(_fbb);
4043 builder_.add_dilation_h_factor(dilation_h_factor);
4044 builder_.add_dilation_w_factor(dilation_w_factor);
4045 builder_.add_stride_h(stride_h);
4046 builder_.add_stride_w(stride_w);
4047 builder_.add_fused_activation_function(fused_activation_function);
4048 builder_.add_padding(padding);
4049 return builder_.Finish();
4050}
4051
4052flatbuffers::Offset<Conv2DOptions> CreateConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4053
4054struct Conv3DOptionsT : public flatbuffers::NativeTable {
4055 typedef Conv3DOptions TableType;
4056 tflite::Padding padding;
4057 int32_t stride_d;
4058 int32_t stride_w;
4059 int32_t stride_h;
4060 tflite::ActivationFunctionType fused_activation_function;
4061 int32_t dilation_d_factor;
4062 int32_t dilation_w_factor;
4063 int32_t dilation_h_factor;
4064 Conv3DOptionsT()
4065 : padding(tflite::Padding_SAME),
4066 stride_d(0),
4067 stride_w(0),
4068 stride_h(0),
4069 fused_activation_function(tflite::ActivationFunctionType_NONE),
4070 dilation_d_factor(1),
4071 dilation_w_factor(1),
4072 dilation_h_factor(1) {
4073 }
4074};
4075
4076struct Conv3DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4077 typedef Conv3DOptionsT NativeTableType;
4078 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4079 VT_PADDING = 4,
4080 VT_STRIDE_D = 6,
4081 VT_STRIDE_W = 8,
4082 VT_STRIDE_H = 10,
4083 VT_FUSED_ACTIVATION_FUNCTION = 12,
4084 VT_DILATION_D_FACTOR = 14,
4085 VT_DILATION_W_FACTOR = 16,
4086 VT_DILATION_H_FACTOR = 18
4087 };
4088 tflite::Padding padding() const {
4089 return static_cast<tflite::Padding>(GetField<int8_t>(VT_PADDING, 0));
4090 }
4091 int32_t stride_d() const {
4092 return GetField<int32_t>(VT_STRIDE_D, 0);
4093 }
4094 int32_t stride_w() const {
4095 return GetField<int32_t>(VT_STRIDE_W, 0);
4096 }
4097 int32_t stride_h() const {
4098 return GetField<int32_t>(VT_STRIDE_H, 0);
4099 }
4100 tflite::ActivationFunctionType fused_activation_function() const {
4101 return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
4102 }
4103 int32_t dilation_d_factor() const {
4104 return GetField<int32_t>(VT_DILATION_D_FACTOR, 1);
4105 }
4106 int32_t dilation_w_factor() const {
4107 return GetField<int32_t>(VT_DILATION_W_FACTOR, 1);
4108 }
4109 int32_t dilation_h_factor() const {
4110 return GetField<int32_t>(VT_DILATION_H_FACTOR, 1);
4111 }
4112 bool Verify(flatbuffers::Verifier &verifier) const {
4113 return VerifyTableStart(verifier) &&
4114 VerifyField<int8_t>(verifier, VT_PADDING) &&
4115 VerifyField<int32_t>(verifier, VT_STRIDE_D) &&
4116 VerifyField<int32_t>(verifier, VT_STRIDE_W) &&
4117 VerifyField<int32_t>(verifier, VT_STRIDE_H) &&
4118 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
4119 VerifyField<int32_t>(verifier, VT_DILATION_D_FACTOR) &&
4120 VerifyField<int32_t>(verifier, VT_DILATION_W_FACTOR) &&
4121 VerifyField<int32_t>(verifier, VT_DILATION_H_FACTOR) &&
4122 verifier.EndTable();
4123 }
4124 Conv3DOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4125 void UnPackTo(Conv3DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4126 static flatbuffers::Offset<Conv3DOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv3DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4127};
4128
4129struct Conv3DOptionsBuilder {
4130 flatbuffers::FlatBufferBuilder &fbb_;
4131 flatbuffers::uoffset_t start_;
4132 void add_padding(tflite::Padding padding) {
4133 fbb_.AddElement<int8_t>(Conv3DOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
4134 }
4135 void add_stride_d(int32_t stride_d) {
4136 fbb_.AddElement<int32_t>(Conv3DOptions::VT_STRIDE_D, stride_d, 0);
4137 }
4138 void add_stride_w(int32_t stride_w) {
4139 fbb_.AddElement<int32_t>(Conv3DOptions::VT_STRIDE_W, stride_w, 0);
4140 }
4141 void add_stride_h(int32_t stride_h) {
4142 fbb_.AddElement<int32_t>(Conv3DOptions::VT_STRIDE_H, stride_h, 0);
4143 }
4144 void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
4145 fbb_.AddElement<int8_t>(Conv3DOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
4146 }
4147 void add_dilation_d_factor(int32_t dilation_d_factor) {
4148 fbb_.AddElement<int32_t>(Conv3DOptions::VT_DILATION_D_FACTOR, dilation_d_factor, 1);
4149 }
4150 void add_dilation_w_factor(int32_t dilation_w_factor) {
4151 fbb_.AddElement<int32_t>(Conv3DOptions::VT_DILATION_W_FACTOR, dilation_w_factor, 1);
4152 }
4153 void add_dilation_h_factor(int32_t dilation_h_factor) {
4154 fbb_.AddElement<int32_t>(Conv3DOptions::VT_DILATION_H_FACTOR, dilation_h_factor, 1);
4155 }
4156 explicit Conv3DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4157 : fbb_(_fbb) {
4158 start_ = fbb_.StartTable();
4159 }
4160 Conv3DOptionsBuilder &operator=(const Conv3DOptionsBuilder &);
4161 flatbuffers::Offset<Conv3DOptions> Finish() {
4162 const auto end = fbb_.EndTable(start_);
4163 auto o = flatbuffers::Offset<Conv3DOptions>(end);
4164 return o;
4165 }
4166};
4167
4168inline flatbuffers::Offset<Conv3DOptions> CreateConv3DOptions(
4169 flatbuffers::FlatBufferBuilder &_fbb,
4170 tflite::Padding padding = tflite::Padding_SAME,
4171 int32_t stride_d = 0,
4172 int32_t stride_w = 0,
4173 int32_t stride_h = 0,
4174 tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
4175 int32_t dilation_d_factor = 1,
4176 int32_t dilation_w_factor = 1,
4177 int32_t dilation_h_factor = 1) {
4178 Conv3DOptionsBuilder builder_(_fbb);
4179 builder_.add_dilation_h_factor(dilation_h_factor);
4180 builder_.add_dilation_w_factor(dilation_w_factor);
4181 builder_.add_dilation_d_factor(dilation_d_factor);
4182 builder_.add_stride_h(stride_h);
4183 builder_.add_stride_w(stride_w);
4184 builder_.add_stride_d(stride_d);
4185 builder_.add_fused_activation_function(fused_activation_function);
4186 builder_.add_padding(padding);
4187 return builder_.Finish();
4188}
4189
4190flatbuffers::Offset<Conv3DOptions> CreateConv3DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Conv3DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4191
4192struct Pool2DOptionsT : public flatbuffers::NativeTable {
4193 typedef Pool2DOptions TableType;
4194 tflite::Padding padding;
4195 int32_t stride_w;
4196 int32_t stride_h;
4197 int32_t filter_width;
4198 int32_t filter_height;
4199 tflite::ActivationFunctionType fused_activation_function;
4200 Pool2DOptionsT()
4201 : padding(tflite::Padding_SAME),
4202 stride_w(0),
4203 stride_h(0),
4204 filter_width(0),
4205 filter_height(0),
4206 fused_activation_function(tflite::ActivationFunctionType_NONE) {
4207 }
4208};
4209
4210struct Pool2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4211 typedef Pool2DOptionsT NativeTableType;
4212 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4213 VT_PADDING = 4,
4214 VT_STRIDE_W = 6,
4215 VT_STRIDE_H = 8,
4216 VT_FILTER_WIDTH = 10,
4217 VT_FILTER_HEIGHT = 12,
4218 VT_FUSED_ACTIVATION_FUNCTION = 14
4219 };
4220 tflite::Padding padding() const {
4221 return static_cast<tflite::Padding>(GetField<int8_t>(VT_PADDING, 0));
4222 }
4223 int32_t stride_w() const {
4224 return GetField<int32_t>(VT_STRIDE_W, 0);
4225 }
4226 int32_t stride_h() const {
4227 return GetField<int32_t>(VT_STRIDE_H, 0);
4228 }
4229 int32_t filter_width() const {
4230 return GetField<int32_t>(VT_FILTER_WIDTH, 0);
4231 }
4232 int32_t filter_height() const {
4233 return GetField<int32_t>(VT_FILTER_HEIGHT, 0);
4234 }
4235 tflite::ActivationFunctionType fused_activation_function() const {
4236 return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
4237 }
4238 bool Verify(flatbuffers::Verifier &verifier) const {
4239 return VerifyTableStart(verifier) &&
4240 VerifyField<int8_t>(verifier, VT_PADDING) &&
4241 VerifyField<int32_t>(verifier, VT_STRIDE_W) &&
4242 VerifyField<int32_t>(verifier, VT_STRIDE_H) &&
4243 VerifyField<int32_t>(verifier, VT_FILTER_WIDTH) &&
4244 VerifyField<int32_t>(verifier, VT_FILTER_HEIGHT) &&
4245 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
4246 verifier.EndTable();
4247 }
4248 Pool2DOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4249 void UnPackTo(Pool2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4250 static flatbuffers::Offset<Pool2DOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4251};
4252
4253struct Pool2DOptionsBuilder {
4254 flatbuffers::FlatBufferBuilder &fbb_;
4255 flatbuffers::uoffset_t start_;
4256 void add_padding(tflite::Padding padding) {
4257 fbb_.AddElement<int8_t>(Pool2DOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
4258 }
4259 void add_stride_w(int32_t stride_w) {
4260 fbb_.AddElement<int32_t>(Pool2DOptions::VT_STRIDE_W, stride_w, 0);
4261 }
4262 void add_stride_h(int32_t stride_h) {
4263 fbb_.AddElement<int32_t>(Pool2DOptions::VT_STRIDE_H, stride_h, 0);
4264 }
4265 void add_filter_width(int32_t filter_width) {
4266 fbb_.AddElement<int32_t>(Pool2DOptions::VT_FILTER_WIDTH, filter_width, 0);
4267 }
4268 void add_filter_height(int32_t filter_height) {
4269 fbb_.AddElement<int32_t>(Pool2DOptions::VT_FILTER_HEIGHT, filter_height, 0);
4270 }
4271 void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
4272 fbb_.AddElement<int8_t>(Pool2DOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
4273 }
4274 explicit Pool2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4275 : fbb_(_fbb) {
4276 start_ = fbb_.StartTable();
4277 }
4278 Pool2DOptionsBuilder &operator=(const Pool2DOptionsBuilder &);
4279 flatbuffers::Offset<Pool2DOptions> Finish() {
4280 const auto end = fbb_.EndTable(start_);
4281 auto o = flatbuffers::Offset<Pool2DOptions>(end);
4282 return o;
4283 }
4284};
4285
4286inline flatbuffers::Offset<Pool2DOptions> CreatePool2DOptions(
4287 flatbuffers::FlatBufferBuilder &_fbb,
4288 tflite::Padding padding = tflite::Padding_SAME,
4289 int32_t stride_w = 0,
4290 int32_t stride_h = 0,
4291 int32_t filter_width = 0,
4292 int32_t filter_height = 0,
4293 tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE) {
4294 Pool2DOptionsBuilder builder_(_fbb);
4295 builder_.add_filter_height(filter_height);
4296 builder_.add_filter_width(filter_width);
4297 builder_.add_stride_h(stride_h);
4298 builder_.add_stride_w(stride_w);
4299 builder_.add_fused_activation_function(fused_activation_function);
4300 builder_.add_padding(padding);
4301 return builder_.Finish();
4302}
4303
4304flatbuffers::Offset<Pool2DOptions> CreatePool2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4305
4306struct DepthwiseConv2DOptionsT : public flatbuffers::NativeTable {
4307 typedef DepthwiseConv2DOptions TableType;
4308 tflite::Padding padding;
4309 int32_t stride_w;
4310 int32_t stride_h;
4311 int32_t depth_multiplier;
4312 tflite::ActivationFunctionType fused_activation_function;
4313 int32_t dilation_w_factor;
4314 int32_t dilation_h_factor;
4315 DepthwiseConv2DOptionsT()
4316 : padding(tflite::Padding_SAME),
4317 stride_w(0),
4318 stride_h(0),
4319 depth_multiplier(0),
4320 fused_activation_function(tflite::ActivationFunctionType_NONE),
4321 dilation_w_factor(1),
4322 dilation_h_factor(1) {
4323 }
4324};
4325
4326struct DepthwiseConv2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4327 typedef DepthwiseConv2DOptionsT NativeTableType;
4328 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4329 VT_PADDING = 4,
4330 VT_STRIDE_W = 6,
4331 VT_STRIDE_H = 8,
4332 VT_DEPTH_MULTIPLIER = 10,
4333 VT_FUSED_ACTIVATION_FUNCTION = 12,
4334 VT_DILATION_W_FACTOR = 14,
4335 VT_DILATION_H_FACTOR = 16
4336 };
4337 tflite::Padding padding() const {
4338 return static_cast<tflite::Padding>(GetField<int8_t>(VT_PADDING, 0));
4339 }
4340 int32_t stride_w() const {
4341 return GetField<int32_t>(VT_STRIDE_W, 0);
4342 }
4343 int32_t stride_h() const {
4344 return GetField<int32_t>(VT_STRIDE_H, 0);
4345 }
4346 int32_t depth_multiplier() const {
4347 return GetField<int32_t>(VT_DEPTH_MULTIPLIER, 0);
4348 }
4349 tflite::ActivationFunctionType fused_activation_function() const {
4350 return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
4351 }
4352 int32_t dilation_w_factor() const {
4353 return GetField<int32_t>(VT_DILATION_W_FACTOR, 1);
4354 }
4355 int32_t dilation_h_factor() const {
4356 return GetField<int32_t>(VT_DILATION_H_FACTOR, 1);
4357 }
4358 bool Verify(flatbuffers::Verifier &verifier) const {
4359 return VerifyTableStart(verifier) &&
4360 VerifyField<int8_t>(verifier, VT_PADDING) &&
4361 VerifyField<int32_t>(verifier, VT_STRIDE_W) &&
4362 VerifyField<int32_t>(verifier, VT_STRIDE_H) &&
4363 VerifyField<int32_t>(verifier, VT_DEPTH_MULTIPLIER) &&
4364 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
4365 VerifyField<int32_t>(verifier, VT_DILATION_W_FACTOR) &&
4366 VerifyField<int32_t>(verifier, VT_DILATION_H_FACTOR) &&
4367 verifier.EndTable();
4368 }
4369 DepthwiseConv2DOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4370 void UnPackTo(DepthwiseConv2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4371 static flatbuffers::Offset<DepthwiseConv2DOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4372};
4373
4374struct DepthwiseConv2DOptionsBuilder {
4375 flatbuffers::FlatBufferBuilder &fbb_;
4376 flatbuffers::uoffset_t start_;
4377 void add_padding(tflite::Padding padding) {
4378 fbb_.AddElement<int8_t>(DepthwiseConv2DOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
4379 }
4380 void add_stride_w(int32_t stride_w) {
4381 fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_STRIDE_W, stride_w, 0);
4382 }
4383 void add_stride_h(int32_t stride_h) {
4384 fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_STRIDE_H, stride_h, 0);
4385 }
4386 void add_depth_multiplier(int32_t depth_multiplier) {
4387 fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_DEPTH_MULTIPLIER, depth_multiplier, 0);
4388 }
4389 void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
4390 fbb_.AddElement<int8_t>(DepthwiseConv2DOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
4391 }
4392 void add_dilation_w_factor(int32_t dilation_w_factor) {
4393 fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_DILATION_W_FACTOR, dilation_w_factor, 1);
4394 }
4395 void add_dilation_h_factor(int32_t dilation_h_factor) {
4396 fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_DILATION_H_FACTOR, dilation_h_factor, 1);
4397 }
4398 explicit DepthwiseConv2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4399 : fbb_(_fbb) {
4400 start_ = fbb_.StartTable();
4401 }
4402 DepthwiseConv2DOptionsBuilder &operator=(const DepthwiseConv2DOptionsBuilder &);
4403 flatbuffers::Offset<DepthwiseConv2DOptions> Finish() {
4404 const auto end = fbb_.EndTable(start_);
4405 auto o = flatbuffers::Offset<DepthwiseConv2DOptions>(end);
4406 return o;
4407 }
4408};
4409
4410inline flatbuffers::Offset<DepthwiseConv2DOptions> CreateDepthwiseConv2DOptions(
4411 flatbuffers::FlatBufferBuilder &_fbb,
4412 tflite::Padding padding = tflite::Padding_SAME,
4413 int32_t stride_w = 0,
4414 int32_t stride_h = 0,
4415 int32_t depth_multiplier = 0,
4416 tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
4417 int32_t dilation_w_factor = 1,
4418 int32_t dilation_h_factor = 1) {
4419 DepthwiseConv2DOptionsBuilder builder_(_fbb);
4420 builder_.add_dilation_h_factor(dilation_h_factor);
4421 builder_.add_dilation_w_factor(dilation_w_factor);
4422 builder_.add_depth_multiplier(depth_multiplier);
4423 builder_.add_stride_h(stride_h);
4424 builder_.add_stride_w(stride_w);
4425 builder_.add_fused_activation_function(fused_activation_function);
4426 builder_.add_padding(padding);
4427 return builder_.Finish();
4428}
4429
4430flatbuffers::Offset<DepthwiseConv2DOptions> CreateDepthwiseConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4431
4432struct ConcatEmbeddingsOptionsT : public flatbuffers::NativeTable {
4433 typedef ConcatEmbeddingsOptions TableType;
4434 int32_t num_channels;
4435 std::vector<int32_t> num_columns_per_channel;
4436 std::vector<int32_t> embedding_dim_per_channel;
4437 ConcatEmbeddingsOptionsT()
4438 : num_channels(0) {
4439 }
4440};
4441
4442struct ConcatEmbeddingsOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4443 typedef ConcatEmbeddingsOptionsT NativeTableType;
4444 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4445 VT_NUM_CHANNELS = 4,
4446 VT_NUM_COLUMNS_PER_CHANNEL = 6,
4447 VT_EMBEDDING_DIM_PER_CHANNEL = 8
4448 };
4449 int32_t num_channels() const {
4450 return GetField<int32_t>(VT_NUM_CHANNELS, 0);
4451 }
4452 const flatbuffers::Vector<int32_t> *num_columns_per_channel() const {
4453 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_NUM_COLUMNS_PER_CHANNEL);
4454 }
4455 const flatbuffers::Vector<int32_t> *embedding_dim_per_channel() const {
4456 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_EMBEDDING_DIM_PER_CHANNEL);
4457 }
4458 bool Verify(flatbuffers::Verifier &verifier) const {
4459 return VerifyTableStart(verifier) &&
4460 VerifyField<int32_t>(verifier, VT_NUM_CHANNELS) &&
4461 VerifyOffset(verifier, VT_NUM_COLUMNS_PER_CHANNEL) &&
4462 verifier.VerifyVector(num_columns_per_channel()) &&
4463 VerifyOffset(verifier, VT_EMBEDDING_DIM_PER_CHANNEL) &&
4464 verifier.VerifyVector(embedding_dim_per_channel()) &&
4465 verifier.EndTable();
4466 }
4467 ConcatEmbeddingsOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4468 void UnPackTo(ConcatEmbeddingsOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4469 static flatbuffers::Offset<ConcatEmbeddingsOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4470};
4471
4472struct ConcatEmbeddingsOptionsBuilder {
4473 flatbuffers::FlatBufferBuilder &fbb_;
4474 flatbuffers::uoffset_t start_;
4475 void add_num_channels(int32_t num_channels) {
4476 fbb_.AddElement<int32_t>(ConcatEmbeddingsOptions::VT_NUM_CHANNELS, num_channels, 0);
4477 }
4478 void add_num_columns_per_channel(flatbuffers::Offset<flatbuffers::Vector<int32_t>> num_columns_per_channel) {
4479 fbb_.AddOffset(ConcatEmbeddingsOptions::VT_NUM_COLUMNS_PER_CHANNEL, num_columns_per_channel);
4480 }
4481 void add_embedding_dim_per_channel(flatbuffers::Offset<flatbuffers::Vector<int32_t>> embedding_dim_per_channel) {
4482 fbb_.AddOffset(ConcatEmbeddingsOptions::VT_EMBEDDING_DIM_PER_CHANNEL, embedding_dim_per_channel);
4483 }
4484 explicit ConcatEmbeddingsOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4485 : fbb_(_fbb) {
4486 start_ = fbb_.StartTable();
4487 }
4488 ConcatEmbeddingsOptionsBuilder &operator=(const ConcatEmbeddingsOptionsBuilder &);
4489 flatbuffers::Offset<ConcatEmbeddingsOptions> Finish() {
4490 const auto end = fbb_.EndTable(start_);
4491 auto o = flatbuffers::Offset<ConcatEmbeddingsOptions>(end);
4492 return o;
4493 }
4494};
4495
4496inline flatbuffers::Offset<ConcatEmbeddingsOptions> CreateConcatEmbeddingsOptions(
4497 flatbuffers::FlatBufferBuilder &_fbb,
4498 int32_t num_channels = 0,
4499 flatbuffers::Offset<flatbuffers::Vector<int32_t>> num_columns_per_channel = 0,
4500 flatbuffers::Offset<flatbuffers::Vector<int32_t>> embedding_dim_per_channel = 0) {
4501 ConcatEmbeddingsOptionsBuilder builder_(_fbb);
4502 builder_.add_embedding_dim_per_channel(embedding_dim_per_channel);
4503 builder_.add_num_columns_per_channel(num_columns_per_channel);
4504 builder_.add_num_channels(num_channels);
4505 return builder_.Finish();
4506}
4507
4508inline flatbuffers::Offset<ConcatEmbeddingsOptions> CreateConcatEmbeddingsOptionsDirect(
4509 flatbuffers::FlatBufferBuilder &_fbb,
4510 int32_t num_channels = 0,
4511 const std::vector<int32_t> *num_columns_per_channel = nullptr,
4512 const std::vector<int32_t> *embedding_dim_per_channel = nullptr) {
4513 auto num_columns_per_channel__ = num_columns_per_channel ? _fbb.CreateVector<int32_t>(*num_columns_per_channel) : 0;
4514 auto embedding_dim_per_channel__ = embedding_dim_per_channel ? _fbb.CreateVector<int32_t>(*embedding_dim_per_channel) : 0;
4515 return tflite::CreateConcatEmbeddingsOptions(
4516 _fbb,
4517 num_channels,
4518 num_columns_per_channel__,
4519 embedding_dim_per_channel__);
4520}
4521
4522flatbuffers::Offset<ConcatEmbeddingsOptions> CreateConcatEmbeddingsOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4523
4524struct LSHProjectionOptionsT : public flatbuffers::NativeTable {
4525 typedef LSHProjectionOptions TableType;
4526 tflite::LSHProjectionType type;
4527 LSHProjectionOptionsT()
4528 : type(tflite::LSHProjectionType_UNKNOWN) {
4529 }
4530};
4531
4532struct LSHProjectionOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4533 typedef LSHProjectionOptionsT NativeTableType;
4534 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4535 VT_TYPE = 4
4536 };
4537 tflite::LSHProjectionType type() const {
4538 return static_cast<tflite::LSHProjectionType>(GetField<int8_t>(VT_TYPE, 0));
4539 }
4540 bool Verify(flatbuffers::Verifier &verifier) const {
4541 return VerifyTableStart(verifier) &&
4542 VerifyField<int8_t>(verifier, VT_TYPE) &&
4543 verifier.EndTable();
4544 }
4545 LSHProjectionOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4546 void UnPackTo(LSHProjectionOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4547 static flatbuffers::Offset<LSHProjectionOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4548};
4549
4550struct LSHProjectionOptionsBuilder {
4551 flatbuffers::FlatBufferBuilder &fbb_;
4552 flatbuffers::uoffset_t start_;
4553 void add_type(tflite::LSHProjectionType type) {
4554 fbb_.AddElement<int8_t>(LSHProjectionOptions::VT_TYPE, static_cast<int8_t>(type), 0);
4555 }
4556 explicit LSHProjectionOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4557 : fbb_(_fbb) {
4558 start_ = fbb_.StartTable();
4559 }
4560 LSHProjectionOptionsBuilder &operator=(const LSHProjectionOptionsBuilder &);
4561 flatbuffers::Offset<LSHProjectionOptions> Finish() {
4562 const auto end = fbb_.EndTable(start_);
4563 auto o = flatbuffers::Offset<LSHProjectionOptions>(end);
4564 return o;
4565 }
4566};
4567
4568inline flatbuffers::Offset<LSHProjectionOptions> CreateLSHProjectionOptions(
4569 flatbuffers::FlatBufferBuilder &_fbb,
4570 tflite::LSHProjectionType type = tflite::LSHProjectionType_UNKNOWN) {
4571 LSHProjectionOptionsBuilder builder_(_fbb);
4572 builder_.add_type(type);
4573 return builder_.Finish();
4574}
4575
4576flatbuffers::Offset<LSHProjectionOptions> CreateLSHProjectionOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4577
4578struct SVDFOptionsT : public flatbuffers::NativeTable {
4579 typedef SVDFOptions TableType;
4580 int32_t rank;
4581 tflite::ActivationFunctionType fused_activation_function;
4582 bool asymmetric_quantize_inputs;
4583 SVDFOptionsT()
4584 : rank(0),
4585 fused_activation_function(tflite::ActivationFunctionType_NONE),
4586 asymmetric_quantize_inputs(false) {
4587 }
4588};
4589
4590struct SVDFOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4591 typedef SVDFOptionsT NativeTableType;
4592 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4593 VT_RANK = 4,
4594 VT_FUSED_ACTIVATION_FUNCTION = 6,
4595 VT_ASYMMETRIC_QUANTIZE_INPUTS = 8
4596 };
4597 int32_t rank() const {
4598 return GetField<int32_t>(VT_RANK, 0);
4599 }
4600 tflite::ActivationFunctionType fused_activation_function() const {
4601 return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
4602 }
4603 bool asymmetric_quantize_inputs() const {
4604 return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
4605 }
4606 bool Verify(flatbuffers::Verifier &verifier) const {
4607 return VerifyTableStart(verifier) &&
4608 VerifyField<int32_t>(verifier, VT_RANK) &&
4609 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
4610 VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) &&
4611 verifier.EndTable();
4612 }
4613 SVDFOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4614 void UnPackTo(SVDFOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4615 static flatbuffers::Offset<SVDFOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4616};
4617
4618struct SVDFOptionsBuilder {
4619 flatbuffers::FlatBufferBuilder &fbb_;
4620 flatbuffers::uoffset_t start_;
4621 void add_rank(int32_t rank) {
4622 fbb_.AddElement<int32_t>(SVDFOptions::VT_RANK, rank, 0);
4623 }
4624 void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
4625 fbb_.AddElement<int8_t>(SVDFOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
4626 }
4627 void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
4628 fbb_.AddElement<uint8_t>(SVDFOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
4629 }
4630 explicit SVDFOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4631 : fbb_(_fbb) {
4632 start_ = fbb_.StartTable();
4633 }
4634 SVDFOptionsBuilder &operator=(const SVDFOptionsBuilder &);
4635 flatbuffers::Offset<SVDFOptions> Finish() {
4636 const auto end = fbb_.EndTable(start_);
4637 auto o = flatbuffers::Offset<SVDFOptions>(end);
4638 return o;
4639 }
4640};
4641
4642inline flatbuffers::Offset<SVDFOptions> CreateSVDFOptions(
4643 flatbuffers::FlatBufferBuilder &_fbb,
4644 int32_t rank = 0,
4645 tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
4646 bool asymmetric_quantize_inputs = false) {
4647 SVDFOptionsBuilder builder_(_fbb);
4648 builder_.add_rank(rank);
4649 builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
4650 builder_.add_fused_activation_function(fused_activation_function);
4651 return builder_.Finish();
4652}
4653
4654flatbuffers::Offset<SVDFOptions> CreateSVDFOptions(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4655
4656struct RNNOptionsT : public flatbuffers::NativeTable {
4657 typedef RNNOptions TableType;
4658 tflite::ActivationFunctionType fused_activation_function;
4659 bool asymmetric_quantize_inputs;
4660 RNNOptionsT()
4661 : fused_activation_function(tflite::ActivationFunctionType_NONE),
4662 asymmetric_quantize_inputs(false) {
4663 }
4664};
4665
4666struct RNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4667 typedef RNNOptionsT NativeTableType;
4668 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4669 VT_FUSED_ACTIVATION_FUNCTION = 4,
4670 VT_ASYMMETRIC_QUANTIZE_INPUTS = 6
4671 };
4672 tflite::ActivationFunctionType fused_activation_function() const {
4673 return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
4674 }
4675 bool asymmetric_quantize_inputs() const {
4676 return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
4677 }
4678 bool Verify(flatbuffers::Verifier &verifier) const {
4679 return VerifyTableStart(verifier) &&
4680 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
4681 VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) &&
4682 verifier.EndTable();
4683 }
4684 RNNOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4685 void UnPackTo(RNNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4686 static flatbuffers::Offset<RNNOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4687};
4688
4689struct RNNOptionsBuilder {
4690 flatbuffers::FlatBufferBuilder &fbb_;
4691 flatbuffers::uoffset_t start_;
4692 void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
4693 fbb_.AddElement<int8_t>(RNNOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
4694 }
4695 void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
4696 fbb_.AddElement<uint8_t>(RNNOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
4697 }
4698 explicit RNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4699 : fbb_(_fbb) {
4700 start_ = fbb_.StartTable();
4701 }
4702 RNNOptionsBuilder &operator=(const RNNOptionsBuilder &);
4703 flatbuffers::Offset<RNNOptions> Finish() {
4704 const auto end = fbb_.EndTable(start_);
4705 auto o = flatbuffers::Offset<RNNOptions>(end);
4706 return o;
4707 }
4708};
4709
4710inline flatbuffers::Offset<RNNOptions> CreateRNNOptions(
4711 flatbuffers::FlatBufferBuilder &_fbb,
4712 tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
4713 bool asymmetric_quantize_inputs = false) {
4714 RNNOptionsBuilder builder_(_fbb);
4715 builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
4716 builder_.add_fused_activation_function(fused_activation_function);
4717 return builder_.Finish();
4718}
4719
4720flatbuffers::Offset<RNNOptions> CreateRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4721
4722struct SequenceRNNOptionsT : public flatbuffers::NativeTable {
4723 typedef SequenceRNNOptions TableType;
4724 bool time_major;
4725 tflite::ActivationFunctionType fused_activation_function;
4726 bool asymmetric_quantize_inputs;
4727 SequenceRNNOptionsT()
4728 : time_major(false),
4729 fused_activation_function(tflite::ActivationFunctionType_NONE),
4730 asymmetric_quantize_inputs(false) {
4731 }
4732};
4733
4734struct SequenceRNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4735 typedef SequenceRNNOptionsT NativeTableType;
4736 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4737 VT_TIME_MAJOR = 4,
4738 VT_FUSED_ACTIVATION_FUNCTION = 6,
4739 VT_ASYMMETRIC_QUANTIZE_INPUTS = 8
4740 };
4741 bool time_major() const {
4742 return GetField<uint8_t>(VT_TIME_MAJOR, 0) != 0;
4743 }
4744 tflite::ActivationFunctionType fused_activation_function() const {
4745 return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
4746 }
4747 bool asymmetric_quantize_inputs() const {
4748 return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
4749 }
4750 bool Verify(flatbuffers::Verifier &verifier) const {
4751 return VerifyTableStart(verifier) &&
4752 VerifyField<uint8_t>(verifier, VT_TIME_MAJOR) &&
4753 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
4754 VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) &&
4755 verifier.EndTable();
4756 }
4757 SequenceRNNOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4758 void UnPackTo(SequenceRNNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4759 static flatbuffers::Offset<SequenceRNNOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4760};
4761
4762struct SequenceRNNOptionsBuilder {
4763 flatbuffers::FlatBufferBuilder &fbb_;
4764 flatbuffers::uoffset_t start_;
4765 void add_time_major(bool time_major) {
4766 fbb_.AddElement<uint8_t>(SequenceRNNOptions::VT_TIME_MAJOR, static_cast<uint8_t>(time_major), 0);
4767 }
4768 void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
4769 fbb_.AddElement<int8_t>(SequenceRNNOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
4770 }
4771 void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
4772 fbb_.AddElement<uint8_t>(SequenceRNNOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
4773 }
4774 explicit SequenceRNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4775 : fbb_(_fbb) {
4776 start_ = fbb_.StartTable();
4777 }
4778 SequenceRNNOptionsBuilder &operator=(const SequenceRNNOptionsBuilder &);
4779 flatbuffers::Offset<SequenceRNNOptions> Finish() {
4780 const auto end = fbb_.EndTable(start_);
4781 auto o = flatbuffers::Offset<SequenceRNNOptions>(end);
4782 return o;
4783 }
4784};
4785
4786inline flatbuffers::Offset<SequenceRNNOptions> CreateSequenceRNNOptions(
4787 flatbuffers::FlatBufferBuilder &_fbb,
4788 bool time_major = false,
4789 tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
4790 bool asymmetric_quantize_inputs = false) {
4791 SequenceRNNOptionsBuilder builder_(_fbb);
4792 builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
4793 builder_.add_fused_activation_function(fused_activation_function);
4794 builder_.add_time_major(time_major);
4795 return builder_.Finish();
4796}
4797
4798flatbuffers::Offset<SequenceRNNOptions> CreateSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4799
4800struct BidirectionalSequenceRNNOptionsT : public flatbuffers::NativeTable {
4801 typedef BidirectionalSequenceRNNOptions TableType;
4802 bool time_major;
4803 tflite::ActivationFunctionType fused_activation_function;
4804 bool merge_outputs;
4805 bool asymmetric_quantize_inputs;
4806 BidirectionalSequenceRNNOptionsT()
4807 : time_major(false),
4808 fused_activation_function(tflite::ActivationFunctionType_NONE),
4809 merge_outputs(false),
4810 asymmetric_quantize_inputs(false) {
4811 }
4812};
4813
4814struct BidirectionalSequenceRNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4815 typedef BidirectionalSequenceRNNOptionsT NativeTableType;
4816 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4817 VT_TIME_MAJOR = 4,
4818 VT_FUSED_ACTIVATION_FUNCTION = 6,
4819 VT_MERGE_OUTPUTS = 8,
4820 VT_ASYMMETRIC_QUANTIZE_INPUTS = 10
4821 };
4822 bool time_major() const {
4823 return GetField<uint8_t>(VT_TIME_MAJOR, 0) != 0;
4824 }
4825 tflite::ActivationFunctionType fused_activation_function() const {
4826 return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
4827 }
4828 bool merge_outputs() const {
4829 return GetField<uint8_t>(VT_MERGE_OUTPUTS, 0) != 0;
4830 }
4831 bool asymmetric_quantize_inputs() const {
4832 return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
4833 }
4834 bool Verify(flatbuffers::Verifier &verifier) const {
4835 return VerifyTableStart(verifier) &&
4836 VerifyField<uint8_t>(verifier, VT_TIME_MAJOR) &&
4837 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
4838 VerifyField<uint8_t>(verifier, VT_MERGE_OUTPUTS) &&
4839 VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) &&
4840 verifier.EndTable();
4841 }
4842 BidirectionalSequenceRNNOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4843 void UnPackTo(BidirectionalSequenceRNNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4844 static flatbuffers::Offset<BidirectionalSequenceRNNOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4845};
4846
4847struct BidirectionalSequenceRNNOptionsBuilder {
4848 flatbuffers::FlatBufferBuilder &fbb_;
4849 flatbuffers::uoffset_t start_;
4850 void add_time_major(bool time_major) {
4851 fbb_.AddElement<uint8_t>(BidirectionalSequenceRNNOptions::VT_TIME_MAJOR, static_cast<uint8_t>(time_major), 0);
4852 }
4853 void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
4854 fbb_.AddElement<int8_t>(BidirectionalSequenceRNNOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
4855 }
4856 void add_merge_outputs(bool merge_outputs) {
4857 fbb_.AddElement<uint8_t>(BidirectionalSequenceRNNOptions::VT_MERGE_OUTPUTS, static_cast<uint8_t>(merge_outputs), 0);
4858 }
4859 void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
4860 fbb_.AddElement<uint8_t>(BidirectionalSequenceRNNOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
4861 }
4862 explicit BidirectionalSequenceRNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4863 : fbb_(_fbb) {
4864 start_ = fbb_.StartTable();
4865 }
4866 BidirectionalSequenceRNNOptionsBuilder &operator=(const BidirectionalSequenceRNNOptionsBuilder &);
4867 flatbuffers::Offset<BidirectionalSequenceRNNOptions> Finish() {
4868 const auto end = fbb_.EndTable(start_);
4869 auto o = flatbuffers::Offset<BidirectionalSequenceRNNOptions>(end);
4870 return o;
4871 }
4872};
4873
4874inline flatbuffers::Offset<BidirectionalSequenceRNNOptions> CreateBidirectionalSequenceRNNOptions(
4875 flatbuffers::FlatBufferBuilder &_fbb,
4876 bool time_major = false,
4877 tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
4878 bool merge_outputs = false,
4879 bool asymmetric_quantize_inputs = false) {
4880 BidirectionalSequenceRNNOptionsBuilder builder_(_fbb);
4881 builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
4882 builder_.add_merge_outputs(merge_outputs);
4883 builder_.add_fused_activation_function(fused_activation_function);
4884 builder_.add_time_major(time_major);
4885 return builder_.Finish();
4886}
4887
4888flatbuffers::Offset<BidirectionalSequenceRNNOptions> CreateBidirectionalSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4889
4890struct FullyConnectedOptionsT : public flatbuffers::NativeTable {
4891 typedef FullyConnectedOptions TableType;
4892 tflite::ActivationFunctionType fused_activation_function;
4893 tflite::FullyConnectedOptionsWeightsFormat weights_format;
4894 bool keep_num_dims;
4895 bool asymmetric_quantize_inputs;
4896 FullyConnectedOptionsT()
4897 : fused_activation_function(tflite::ActivationFunctionType_NONE),
4898 weights_format(tflite::FullyConnectedOptionsWeightsFormat_DEFAULT),
4899 keep_num_dims(false),
4900 asymmetric_quantize_inputs(false) {
4901 }
4902};
4903
4904struct FullyConnectedOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4905 typedef FullyConnectedOptionsT NativeTableType;
4906 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4907 VT_FUSED_ACTIVATION_FUNCTION = 4,
4908 VT_WEIGHTS_FORMAT = 6,
4909 VT_KEEP_NUM_DIMS = 8,
4910 VT_ASYMMETRIC_QUANTIZE_INPUTS = 10
4911 };
4912 tflite::ActivationFunctionType fused_activation_function() const {
4913 return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
4914 }
4915 tflite::FullyConnectedOptionsWeightsFormat weights_format() const {
4916 return static_cast<tflite::FullyConnectedOptionsWeightsFormat>(GetField<int8_t>(VT_WEIGHTS_FORMAT, 0));
4917 }
4918 bool keep_num_dims() const {
4919 return GetField<uint8_t>(VT_KEEP_NUM_DIMS, 0) != 0;
4920 }
4921 bool asymmetric_quantize_inputs() const {
4922 return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
4923 }
4924 bool Verify(flatbuffers::Verifier &verifier) const {
4925 return VerifyTableStart(verifier) &&
4926 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
4927 VerifyField<int8_t>(verifier, VT_WEIGHTS_FORMAT) &&
4928 VerifyField<uint8_t>(verifier, VT_KEEP_NUM_DIMS) &&
4929 VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) &&
4930 verifier.EndTable();
4931 }
4932 FullyConnectedOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4933 void UnPackTo(FullyConnectedOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4934 static flatbuffers::Offset<FullyConnectedOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4935};
4936
4937struct FullyConnectedOptionsBuilder {
4938 flatbuffers::FlatBufferBuilder &fbb_;
4939 flatbuffers::uoffset_t start_;
4940 void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
4941 fbb_.AddElement<int8_t>(FullyConnectedOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
4942 }
4943 void add_weights_format(tflite::FullyConnectedOptionsWeightsFormat weights_format) {
4944 fbb_.AddElement<int8_t>(FullyConnectedOptions::VT_WEIGHTS_FORMAT, static_cast<int8_t>(weights_format), 0);
4945 }
4946 void add_keep_num_dims(bool keep_num_dims) {
4947 fbb_.AddElement<uint8_t>(FullyConnectedOptions::VT_KEEP_NUM_DIMS, static_cast<uint8_t>(keep_num_dims), 0);
4948 }
4949 void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
4950 fbb_.AddElement<uint8_t>(FullyConnectedOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
4951 }
4952 explicit FullyConnectedOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4953 : fbb_(_fbb) {
4954 start_ = fbb_.StartTable();
4955 }
4956 FullyConnectedOptionsBuilder &operator=(const FullyConnectedOptionsBuilder &);
4957 flatbuffers::Offset<FullyConnectedOptions> Finish() {
4958 const auto end = fbb_.EndTable(start_);
4959 auto o = flatbuffers::Offset<FullyConnectedOptions>(end);
4960 return o;
4961 }
4962};
4963
4964inline flatbuffers::Offset<FullyConnectedOptions> CreateFullyConnectedOptions(
4965 flatbuffers::FlatBufferBuilder &_fbb,
4966 tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
4967 tflite::FullyConnectedOptionsWeightsFormat weights_format = tflite::FullyConnectedOptionsWeightsFormat_DEFAULT,
4968 bool keep_num_dims = false,
4969 bool asymmetric_quantize_inputs = false) {
4970 FullyConnectedOptionsBuilder builder_(_fbb);
4971 builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
4972 builder_.add_keep_num_dims(keep_num_dims);
4973 builder_.add_weights_format(weights_format);
4974 builder_.add_fused_activation_function(fused_activation_function);
4975 return builder_.Finish();
4976}
4977
4978flatbuffers::Offset<FullyConnectedOptions> CreateFullyConnectedOptions(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4979
4980struct SoftmaxOptionsT : public flatbuffers::NativeTable {
4981 typedef SoftmaxOptions TableType;
4982 float beta;
4983 SoftmaxOptionsT()
4984 : beta(0.0f) {
4985 }
4986};
4987
4988struct SoftmaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4989 typedef SoftmaxOptionsT NativeTableType;
4990 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4991 VT_BETA = 4
4992 };
4993 float beta() const {
4994 return GetField<float>(VT_BETA, 0.0f);
4995 }
4996 bool Verify(flatbuffers::Verifier &verifier) const {
4997 return VerifyTableStart(verifier) &&
4998 VerifyField<float>(verifier, VT_BETA) &&
4999 verifier.EndTable();
5000 }
5001 SoftmaxOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5002 void UnPackTo(SoftmaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5003 static flatbuffers::Offset<SoftmaxOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5004};
5005
5006struct SoftmaxOptionsBuilder {
5007 flatbuffers::FlatBufferBuilder &fbb_;
5008 flatbuffers::uoffset_t start_;
5009 void add_beta(float beta) {
5010 fbb_.AddElement<float>(SoftmaxOptions::VT_BETA, beta, 0.0f);
5011 }
5012 explicit SoftmaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5013 : fbb_(_fbb) {
5014 start_ = fbb_.StartTable();
5015 }
5016 SoftmaxOptionsBuilder &operator=(const SoftmaxOptionsBuilder &);
5017 flatbuffers::Offset<SoftmaxOptions> Finish() {
5018 const auto end = fbb_.EndTable(start_);
5019 auto o = flatbuffers::Offset<SoftmaxOptions>(end);
5020 return o;
5021 }
5022};
5023
5024inline flatbuffers::Offset<SoftmaxOptions> CreateSoftmaxOptions(
5025 flatbuffers::FlatBufferBuilder &_fbb,
5026 float beta = 0.0f) {
5027 SoftmaxOptionsBuilder builder_(_fbb);
5028 builder_.add_beta(beta);
5029 return builder_.Finish();
5030}
5031
5032flatbuffers::Offset<SoftmaxOptions> CreateSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5033
5034struct ConcatenationOptionsT : public flatbuffers::NativeTable {
5035 typedef ConcatenationOptions TableType;
5036 int32_t axis;
5037 tflite::ActivationFunctionType fused_activation_function;
5038 ConcatenationOptionsT()
5039 : axis(0),
5040 fused_activation_function(tflite::ActivationFunctionType_NONE) {
5041 }
5042};
5043
5044struct ConcatenationOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5045 typedef ConcatenationOptionsT NativeTableType;
5046 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5047 VT_AXIS = 4,
5048 VT_FUSED_ACTIVATION_FUNCTION = 6
5049 };
5050 int32_t axis() const {
5051 return GetField<int32_t>(VT_AXIS, 0);
5052 }
5053 tflite::ActivationFunctionType fused_activation_function() const {
5054 return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
5055 }
5056 bool Verify(flatbuffers::Verifier &verifier) const {
5057 return VerifyTableStart(verifier) &&
5058 VerifyField<int32_t>(verifier, VT_AXIS) &&
5059 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
5060 verifier.EndTable();
5061 }
5062 ConcatenationOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5063 void UnPackTo(ConcatenationOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5064 static flatbuffers::Offset<ConcatenationOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5065};
5066
5067struct ConcatenationOptionsBuilder {
5068 flatbuffers::FlatBufferBuilder &fbb_;
5069 flatbuffers::uoffset_t start_;
5070 void add_axis(int32_t axis) {
5071 fbb_.AddElement<int32_t>(ConcatenationOptions::VT_AXIS, axis, 0);
5072 }
5073 void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
5074 fbb_.AddElement<int8_t>(ConcatenationOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
5075 }
5076 explicit ConcatenationOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5077 : fbb_(_fbb) {
5078 start_ = fbb_.StartTable();
5079 }
5080 ConcatenationOptionsBuilder &operator=(const ConcatenationOptionsBuilder &);
5081 flatbuffers::Offset<ConcatenationOptions> Finish() {
5082 const auto end = fbb_.EndTable(start_);
5083 auto o = flatbuffers::Offset<ConcatenationOptions>(end);
5084 return o;
5085 }
5086};
5087
5088inline flatbuffers::Offset<ConcatenationOptions> CreateConcatenationOptions(
5089 flatbuffers::FlatBufferBuilder &_fbb,
5090 int32_t axis = 0,
5091 tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE) {
5092 ConcatenationOptionsBuilder builder_(_fbb);
5093 builder_.add_axis(axis);
5094 builder_.add_fused_activation_function(fused_activation_function);
5095 return builder_.Finish();
5096}
5097
5098flatbuffers::Offset<ConcatenationOptions> CreateConcatenationOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5099
5100struct AddOptionsT : public flatbuffers::NativeTable {
5101 typedef AddOptions TableType;
5102 tflite::ActivationFunctionType fused_activation_function;
5103 bool pot_scale_int16;
5104 AddOptionsT()
5105 : fused_activation_function(tflite::ActivationFunctionType_NONE),
5106 pot_scale_int16(true) {
5107 }
5108};
5109
5110struct AddOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5111 typedef AddOptionsT NativeTableType;
5112 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5113 VT_FUSED_ACTIVATION_FUNCTION = 4,
5114 VT_POT_SCALE_INT16 = 6
5115 };
5116 tflite::ActivationFunctionType fused_activation_function() const {
5117 return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
5118 }
5119 bool pot_scale_int16() const {
5120 return GetField<uint8_t>(VT_POT_SCALE_INT16, 1) != 0;
5121 }
5122 bool Verify(flatbuffers::Verifier &verifier) const {
5123 return VerifyTableStart(verifier) &&
5124 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
5125 VerifyField<uint8_t>(verifier, VT_POT_SCALE_INT16) &&
5126 verifier.EndTable();
5127 }
5128 AddOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5129 void UnPackTo(AddOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5130 static flatbuffers::Offset<AddOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5131};
5132
5133struct AddOptionsBuilder {
5134 flatbuffers::FlatBufferBuilder &fbb_;
5135 flatbuffers::uoffset_t start_;
5136 void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
5137 fbb_.AddElement<int8_t>(AddOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
5138 }
5139 void add_pot_scale_int16(bool pot_scale_int16) {
5140 fbb_.AddElement<uint8_t>(AddOptions::VT_POT_SCALE_INT16, static_cast<uint8_t>(pot_scale_int16), 1);
5141 }
5142 explicit AddOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5143 : fbb_(_fbb) {
5144 start_ = fbb_.StartTable();
5145 }
5146 AddOptionsBuilder &operator=(const AddOptionsBuilder &);
5147 flatbuffers::Offset<AddOptions> Finish() {
5148 const auto end = fbb_.EndTable(start_);
5149 auto o = flatbuffers::Offset<AddOptions>(end);
5150 return o;
5151 }
5152};
5153
5154inline flatbuffers::Offset<AddOptions> CreateAddOptions(
5155 flatbuffers::FlatBufferBuilder &_fbb,
5156 tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
5157 bool pot_scale_int16 = true) {
5158 AddOptionsBuilder builder_(_fbb);
5159 builder_.add_pot_scale_int16(pot_scale_int16);
5160 builder_.add_fused_activation_function(fused_activation_function);
5161 return builder_.Finish();
5162}
5163
5164flatbuffers::Offset<AddOptions> CreateAddOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5165
5166struct MulOptionsT : public flatbuffers::NativeTable {
5167 typedef MulOptions TableType;
5168 tflite::ActivationFunctionType fused_activation_function;
5169 MulOptionsT()
5170 : fused_activation_function(tflite::ActivationFunctionType_NONE) {
5171 }
5172};
5173
5174struct MulOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5175 typedef MulOptionsT NativeTableType;
5176 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5177 VT_FUSED_ACTIVATION_FUNCTION = 4
5178 };
5179 tflite::ActivationFunctionType fused_activation_function() const {
5180 return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
5181 }
5182 bool Verify(flatbuffers::Verifier &verifier) const {
5183 return VerifyTableStart(verifier) &&
5184 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
5185 verifier.EndTable();
5186 }
5187 MulOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5188 void UnPackTo(MulOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5189 static flatbuffers::Offset<MulOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5190};
5191
5192struct MulOptionsBuilder {
5193 flatbuffers::FlatBufferBuilder &fbb_;
5194 flatbuffers::uoffset_t start_;
5195 void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
5196 fbb_.AddElement<int8_t>(MulOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
5197 }
5198 explicit MulOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5199 : fbb_(_fbb) {
5200 start_ = fbb_.StartTable();
5201 }
5202 MulOptionsBuilder &operator=(const MulOptionsBuilder &);
5203 flatbuffers::Offset<MulOptions> Finish() {
5204 const auto end = fbb_.EndTable(start_);
5205 auto o = flatbuffers::Offset<MulOptions>(end);
5206 return o;
5207 }
5208};
5209
5210inline flatbuffers::Offset<MulOptions> CreateMulOptions(
5211 flatbuffers::FlatBufferBuilder &_fbb,
5212 tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE) {
5213 MulOptionsBuilder builder_(_fbb);
5214 builder_.add_fused_activation_function(fused_activation_function);
5215 return builder_.Finish();
5216}
5217
5218flatbuffers::Offset<MulOptions> CreateMulOptions(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5219
5220struct L2NormOptionsT : public flatbuffers::NativeTable {
5221 typedef L2NormOptions TableType;
5222 tflite::ActivationFunctionType fused_activation_function;
5223 L2NormOptionsT()
5224 : fused_activation_function(tflite::ActivationFunctionType_NONE) {
5225 }
5226};
5227
5228struct L2NormOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5229 typedef L2NormOptionsT NativeTableType;
5230 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5231 VT_FUSED_ACTIVATION_FUNCTION = 4
5232 };
5233 tflite::ActivationFunctionType fused_activation_function() const {
5234 return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
5235 }
5236 bool Verify(flatbuffers::Verifier &verifier) const {
5237 return VerifyTableStart(verifier) &&
5238 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
5239 verifier.EndTable();
5240 }
5241 L2NormOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5242 void UnPackTo(L2NormOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5243 static flatbuffers::Offset<L2NormOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5244};
5245
5246struct L2NormOptionsBuilder {
5247 flatbuffers::FlatBufferBuilder &fbb_;
5248 flatbuffers::uoffset_t start_;
5249 void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
5250 fbb_.AddElement<int8_t>(L2NormOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
5251 }
5252 explicit L2NormOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5253 : fbb_(_fbb) {
5254 start_ = fbb_.StartTable();
5255 }
5256 L2NormOptionsBuilder &operator=(const L2NormOptionsBuilder &);
5257 flatbuffers::Offset<L2NormOptions> Finish() {
5258 const auto end = fbb_.EndTable(start_);
5259 auto o = flatbuffers::Offset<L2NormOptions>(end);
5260 return o;
5261 }
5262};
5263
5264inline flatbuffers::Offset<L2NormOptions> CreateL2NormOptions(
5265 flatbuffers::FlatBufferBuilder &_fbb,
5266 tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE) {
5267 L2NormOptionsBuilder builder_(_fbb);
5268 builder_.add_fused_activation_function(fused_activation_function);
5269 return builder_.Finish();
5270}
5271
5272flatbuffers::Offset<L2NormOptions> CreateL2NormOptions(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5273
5274struct LocalResponseNormalizationOptionsT : public flatbuffers::NativeTable {
5275 typedef LocalResponseNormalizationOptions TableType;
5276 int32_t radius;
5277 float bias;
5278 float alpha;
5279 float beta;
5280 LocalResponseNormalizationOptionsT()
5281 : radius(0),
5282 bias(0.0f),
5283 alpha(0.0f),
5284 beta(0.0f) {
5285 }
5286};
5287
5288struct LocalResponseNormalizationOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5289 typedef LocalResponseNormalizationOptionsT NativeTableType;
5290 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5291 VT_RADIUS = 4,
5292 VT_BIAS = 6,
5293 VT_ALPHA = 8,
5294 VT_BETA = 10
5295 };
5296 int32_t radius() const {
5297 return GetField<int32_t>(VT_RADIUS, 0);
5298 }
5299 float bias() const {
5300 return GetField<float>(VT_BIAS, 0.0f);
5301 }
5302 float alpha() const {
5303 return GetField<float>(VT_ALPHA, 0.0f);
5304 }
5305 float beta() const {
5306 return GetField<float>(VT_BETA, 0.0f);
5307 }
5308 bool Verify(flatbuffers::Verifier &verifier) const {
5309 return VerifyTableStart(verifier) &&
5310 VerifyField<int32_t>(verifier, VT_RADIUS) &&
5311 VerifyField<float>(verifier, VT_BIAS) &&
5312 VerifyField<float>(verifier, VT_ALPHA) &&
5313 VerifyField<float>(verifier, VT_BETA) &&
5314 verifier.EndTable();
5315 }
5316 LocalResponseNormalizationOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5317 void UnPackTo(LocalResponseNormalizationOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5318 static flatbuffers::Offset<LocalResponseNormalizationOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5319};
5320
5321struct LocalResponseNormalizationOptionsBuilder {
5322 flatbuffers::FlatBufferBuilder &fbb_;
5323 flatbuffers::uoffset_t start_;
5324 void add_radius(int32_t radius) {
5325 fbb_.AddElement<int32_t>(LocalResponseNormalizationOptions::VT_RADIUS, radius, 0);
5326 }
5327 void add_bias(float bias) {
5328 fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_BIAS, bias, 0.0f);
5329 }
5330 void add_alpha(float alpha) {
5331 fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_ALPHA, alpha, 0.0f);
5332 }
5333 void add_beta(float beta) {
5334 fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_BETA, beta, 0.0f);
5335 }
5336 explicit LocalResponseNormalizationOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5337 : fbb_(_fbb) {
5338 start_ = fbb_.StartTable();
5339 }
5340 LocalResponseNormalizationOptionsBuilder &operator=(const LocalResponseNormalizationOptionsBuilder &);
5341 flatbuffers::Offset<LocalResponseNormalizationOptions> Finish() {
5342 const auto end = fbb_.EndTable(start_);
5343 auto o = flatbuffers::Offset<LocalResponseNormalizationOptions>(end);
5344 return o;
5345 }
5346};
5347
5348inline flatbuffers::Offset<LocalResponseNormalizationOptions> CreateLocalResponseNormalizationOptions(
5349 flatbuffers::FlatBufferBuilder &_fbb,
5350 int32_t radius = 0,
5351 float bias = 0.0f,
5352 float alpha = 0.0f,
5353 float beta = 0.0f) {
5354 LocalResponseNormalizationOptionsBuilder builder_(_fbb);
5355 builder_.add_beta(beta);
5356 builder_.add_alpha(alpha);
5357 builder_.add_bias(bias);
5358 builder_.add_radius(radius);
5359 return builder_.Finish();
5360}
5361
5362flatbuffers::Offset<LocalResponseNormalizationOptions> CreateLocalResponseNormalizationOptions(flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5363
5364struct LSTMOptionsT : public flatbuffers::NativeTable {
5365 typedef LSTMOptions TableType;
5366 tflite::ActivationFunctionType fused_activation_function;
5367 float cell_clip;
5368 float proj_clip;
5369 tflite::LSTMKernelType kernel_type;
5370 bool asymmetric_quantize_inputs;
5371 LSTMOptionsT()
5372 : fused_activation_function(tflite::ActivationFunctionType_NONE),
5373 cell_clip(0.0f),
5374 proj_clip(0.0f),
5375 kernel_type(tflite::LSTMKernelType_FULL),
5376 asymmetric_quantize_inputs(false) {
5377 }
5378};
5379
5380struct LSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5381 typedef LSTMOptionsT NativeTableType;
5382 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5383 VT_FUSED_ACTIVATION_FUNCTION = 4,
5384 VT_CELL_CLIP = 6,
5385 VT_PROJ_CLIP = 8,
5386 VT_KERNEL_TYPE = 10,
5387 VT_ASYMMETRIC_QUANTIZE_INPUTS = 12
5388 };
5389 tflite::ActivationFunctionType fused_activation_function() const {
5390 return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
5391 }
5392 float cell_clip() const {
5393 return GetField<float>(VT_CELL_CLIP, 0.0f);
5394 }
5395 float proj_clip() const {
5396 return GetField<float>(VT_PROJ_CLIP, 0.0f);
5397 }
5398 tflite::LSTMKernelType kernel_type() const {
5399 return static_cast<tflite::LSTMKernelType>(GetField<int8_t>(VT_KERNEL_TYPE, 0));
5400 }
5401 bool asymmetric_quantize_inputs() const {
5402 return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
5403 }
5404 bool Verify(flatbuffers::Verifier &verifier) const {
5405 return VerifyTableStart(verifier) &&
5406 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
5407 VerifyField<float>(verifier, VT_CELL_CLIP) &&
5408 VerifyField<float>(verifier, VT_PROJ_CLIP) &&
5409 VerifyField<int8_t>(verifier, VT_KERNEL_TYPE) &&
5410 VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) &&
5411 verifier.EndTable();
5412 }
5413 LSTMOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5414 void UnPackTo(LSTMOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5415 static flatbuffers::Offset<LSTMOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5416};
5417
5418struct LSTMOptionsBuilder {
5419 flatbuffers::FlatBufferBuilder &fbb_;
5420 flatbuffers::uoffset_t start_;
5421 void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
5422 fbb_.AddElement<int8_t>(LSTMOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
5423 }
5424 void add_cell_clip(float cell_clip) {
5425 fbb_.AddElement<float>(LSTMOptions::VT_CELL_CLIP, cell_clip, 0.0f);
5426 }
5427 void add_proj_clip(float proj_clip) {
5428 fbb_.AddElement<float>(LSTMOptions::VT_PROJ_CLIP, proj_clip, 0.0f);
5429 }
5430 void add_kernel_type(tflite::LSTMKernelType kernel_type) {
5431 fbb_.AddElement<int8_t>(LSTMOptions::VT_KERNEL_TYPE, static_cast<int8_t>(kernel_type), 0);
5432 }
5433 void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
5434 fbb_.AddElement<uint8_t>(LSTMOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
5435 }
5436 explicit LSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5437 : fbb_(_fbb) {
5438 start_ = fbb_.StartTable();
5439 }
5440 LSTMOptionsBuilder &operator=(const LSTMOptionsBuilder &);
5441 flatbuffers::Offset<LSTMOptions> Finish() {
5442 const auto end = fbb_.EndTable(start_);
5443 auto o = flatbuffers::Offset<LSTMOptions>(end);
5444 return o;
5445 }
5446};
5447
5448inline flatbuffers::Offset<LSTMOptions> CreateLSTMOptions(
5449 flatbuffers::FlatBufferBuilder &_fbb,
5450 tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
5451 float cell_clip = 0.0f,
5452 float proj_clip = 0.0f,
5453 tflite::LSTMKernelType kernel_type = tflite::LSTMKernelType_FULL,
5454 bool asymmetric_quantize_inputs = false) {
5455 LSTMOptionsBuilder builder_(_fbb);
5456 builder_.add_proj_clip(proj_clip);
5457 builder_.add_cell_clip(cell_clip);
5458 builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
5459 builder_.add_kernel_type(kernel_type);
5460 builder_.add_fused_activation_function(fused_activation_function);
5461 return builder_.Finish();
5462}
5463
5464flatbuffers::Offset<LSTMOptions> CreateLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5465
5466struct UnidirectionalSequenceLSTMOptionsT : public flatbuffers::NativeTable {
5467 typedef UnidirectionalSequenceLSTMOptions TableType;
5468 tflite::ActivationFunctionType fused_activation_function;
5469 float cell_clip;
5470 float proj_clip;
5471 bool time_major;
5472 bool asymmetric_quantize_inputs;
5473 UnidirectionalSequenceLSTMOptionsT()
5474 : fused_activation_function(tflite::ActivationFunctionType_NONE),
5475 cell_clip(0.0f),
5476 proj_clip(0.0f),
5477 time_major(false),
5478 asymmetric_quantize_inputs(false) {
5479 }
5480};
5481
5482struct UnidirectionalSequenceLSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5483 typedef UnidirectionalSequenceLSTMOptionsT NativeTableType;
5484 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5485 VT_FUSED_ACTIVATION_FUNCTION = 4,
5486 VT_CELL_CLIP = 6,
5487 VT_PROJ_CLIP = 8,
5488 VT_TIME_MAJOR = 10,
5489 VT_ASYMMETRIC_QUANTIZE_INPUTS = 12
5490 };
5491 tflite::ActivationFunctionType fused_activation_function() const {
5492 return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
5493 }
5494 float cell_clip() const {
5495 return GetField<float>(VT_CELL_CLIP, 0.0f);
5496 }
5497 float proj_clip() const {
5498 return GetField<float>(VT_PROJ_CLIP, 0.0f);
5499 }
5500 bool time_major() const {
5501 return GetField<uint8_t>(VT_TIME_MAJOR, 0) != 0;
5502 }
5503 bool asymmetric_quantize_inputs() const {
5504 return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
5505 }
5506 bool Verify(flatbuffers::Verifier &verifier) const {
5507 return VerifyTableStart(verifier) &&
5508 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
5509 VerifyField<float>(verifier, VT_CELL_CLIP) &&
5510 VerifyField<float>(verifier, VT_PROJ_CLIP) &&
5511 VerifyField<uint8_t>(verifier, VT_TIME_MAJOR) &&
5512 VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) &&
5513 verifier.EndTable();
5514 }
5515 UnidirectionalSequenceLSTMOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5516 void UnPackTo(UnidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5517 static flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5518};
5519
5520struct UnidirectionalSequenceLSTMOptionsBuilder {
5521 flatbuffers::FlatBufferBuilder &fbb_;
5522 flatbuffers::uoffset_t start_;
5523 void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
5524 fbb_.AddElement<int8_t>(UnidirectionalSequenceLSTMOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
5525 }
5526 void add_cell_clip(float cell_clip) {
5527 fbb_.AddElement<float>(UnidirectionalSequenceLSTMOptions::VT_CELL_CLIP, cell_clip, 0.0f);
5528 }
5529 void add_proj_clip(float proj_clip) {
5530 fbb_.AddElement<float>(UnidirectionalSequenceLSTMOptions::VT_PROJ_CLIP, proj_clip, 0.0f);
5531 }
5532 void add_time_major(bool time_major) {
5533 fbb_.AddElement<uint8_t>(UnidirectionalSequenceLSTMOptions::VT_TIME_MAJOR, static_cast<uint8_t>(time_major), 0);
5534 }
5535 void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
5536 fbb_.AddElement<uint8_t>(UnidirectionalSequenceLSTMOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
5537 }
5538 explicit UnidirectionalSequenceLSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5539 : fbb_(_fbb) {
5540 start_ = fbb_.StartTable();
5541 }
5542 UnidirectionalSequenceLSTMOptionsBuilder &operator=(const UnidirectionalSequenceLSTMOptionsBuilder &);
5543 flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> Finish() {
5544 const auto end = fbb_.EndTable(start_);
5545 auto o = flatbuffers::Offset<UnidirectionalSequenceLSTMOptions>(end);
5546 return o;
5547 }
5548};
5549
5550inline flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> CreateUnidirectionalSequenceLSTMOptions(
5551 flatbuffers::FlatBufferBuilder &_fbb,
5552 tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
5553 float cell_clip = 0.0f,
5554 float proj_clip = 0.0f,
5555 bool time_major = false,
5556 bool asymmetric_quantize_inputs = false) {
5557 UnidirectionalSequenceLSTMOptionsBuilder builder_(_fbb);
5558 builder_.add_proj_clip(proj_clip);
5559 builder_.add_cell_clip(cell_clip);
5560 builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
5561 builder_.add_time_major(time_major);
5562 builder_.add_fused_activation_function(fused_activation_function);
5563 return builder_.Finish();
5564}
5565
5566flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> CreateUnidirectionalSequenceLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5567
5568struct BidirectionalSequenceLSTMOptionsT : public flatbuffers::NativeTable {
5569 typedef BidirectionalSequenceLSTMOptions TableType;
5570 tflite::ActivationFunctionType fused_activation_function;
5571 float cell_clip;
5572 float proj_clip;
5573 bool merge_outputs;
5574 bool time_major;
5575 bool asymmetric_quantize_inputs;
5576 BidirectionalSequenceLSTMOptionsT()
5577 : fused_activation_function(tflite::ActivationFunctionType_NONE),
5578 cell_clip(0.0f),
5579 proj_clip(0.0f),
5580 merge_outputs(false),
5581 time_major(true),
5582 asymmetric_quantize_inputs(false) {
5583 }
5584};
5585
5586struct BidirectionalSequenceLSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5587 typedef BidirectionalSequenceLSTMOptionsT NativeTableType;
5588 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5589 VT_FUSED_ACTIVATION_FUNCTION = 4,
5590 VT_CELL_CLIP = 6,
5591 VT_PROJ_CLIP = 8,
5592 VT_MERGE_OUTPUTS = 10,
5593 VT_TIME_MAJOR = 12,
5594 VT_ASYMMETRIC_QUANTIZE_INPUTS = 14
5595 };
5596 tflite::ActivationFunctionType fused_activation_function() const {
5597 return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
5598 }
5599 float cell_clip() const {
5600 return GetField<float>(VT_CELL_CLIP, 0.0f);
5601 }
5602 float proj_clip() const {
5603 return GetField<float>(VT_PROJ_CLIP, 0.0f);
5604 }
5605 bool merge_outputs() const {
5606 return GetField<uint8_t>(VT_MERGE_OUTPUTS, 0) != 0;
5607 }
5608 bool time_major() const {
5609 return GetField<uint8_t>(VT_TIME_MAJOR, 1) != 0;
5610 }
5611 bool asymmetric_quantize_inputs() const {
5612 return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
5613 }
5614 bool Verify(flatbuffers::Verifier &verifier) const {
5615 return VerifyTableStart(verifier) &&
5616 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
5617 VerifyField<float>(verifier, VT_CELL_CLIP) &&
5618 VerifyField<float>(verifier, VT_PROJ_CLIP) &&
5619 VerifyField<uint8_t>(verifier, VT_MERGE_OUTPUTS) &&
5620 VerifyField<uint8_t>(verifier, VT_TIME_MAJOR) &&
5621 VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) &&
5622 verifier.EndTable();
5623 }
5624 BidirectionalSequenceLSTMOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5625 void UnPackTo(BidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5626 static flatbuffers::Offset<BidirectionalSequenceLSTMOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5627};
5628
5629struct BidirectionalSequenceLSTMOptionsBuilder {
5630 flatbuffers::FlatBufferBuilder &fbb_;
5631 flatbuffers::uoffset_t start_;
5632 void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
5633 fbb_.AddElement<int8_t>(BidirectionalSequenceLSTMOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
5634 }
5635 void add_cell_clip(float cell_clip) {
5636 fbb_.AddElement<float>(BidirectionalSequenceLSTMOptions::VT_CELL_CLIP, cell_clip, 0.0f);
5637 }
5638 void add_proj_clip(float proj_clip) {
5639 fbb_.AddElement<float>(BidirectionalSequenceLSTMOptions::VT_PROJ_CLIP, proj_clip, 0.0f);
5640 }
5641 void add_merge_outputs(bool merge_outputs) {
5642 fbb_.AddElement<uint8_t>(BidirectionalSequenceLSTMOptions::VT_MERGE_OUTPUTS, static_cast<uint8_t>(merge_outputs), 0);
5643 }
5644 void add_time_major(bool time_major) {
5645 fbb_.AddElement<uint8_t>(BidirectionalSequenceLSTMOptions::VT_TIME_MAJOR, static_cast<uint8_t>(time_major), 1);
5646 }
5647 void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
5648 fbb_.AddElement<uint8_t>(BidirectionalSequenceLSTMOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
5649 }
5650 explicit BidirectionalSequenceLSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5651 : fbb_(_fbb) {
5652 start_ = fbb_.StartTable();
5653 }
5654 BidirectionalSequenceLSTMOptionsBuilder &operator=(const BidirectionalSequenceLSTMOptionsBuilder &);
5655 flatbuffers::Offset<BidirectionalSequenceLSTMOptions> Finish() {
5656 const auto end = fbb_.EndTable(start_);
5657 auto o = flatbuffers::Offset<BidirectionalSequenceLSTMOptions>(end);
5658 return o;
5659 }
5660};
5661
5662inline flatbuffers::Offset<BidirectionalSequenceLSTMOptions> CreateBidirectionalSequenceLSTMOptions(
5663 flatbuffers::FlatBufferBuilder &_fbb,
5664 tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
5665 float cell_clip = 0.0f,
5666 float proj_clip = 0.0f,
5667 bool merge_outputs = false,
5668 bool time_major = true,
5669 bool asymmetric_quantize_inputs = false) {
5670 BidirectionalSequenceLSTMOptionsBuilder builder_(_fbb);
5671 builder_.add_proj_clip(proj_clip);
5672 builder_.add_cell_clip(cell_clip);
5673 builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
5674 builder_.add_time_major(time_major);
5675 builder_.add_merge_outputs(merge_outputs);
5676 builder_.add_fused_activation_function(fused_activation_function);
5677 return builder_.Finish();
5678}
5679
5680flatbuffers::Offset<BidirectionalSequenceLSTMOptions> CreateBidirectionalSequenceLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5681
5682struct ResizeBilinearOptionsT : public flatbuffers::NativeTable {
5683 typedef ResizeBilinearOptions TableType;
5684 bool align_corners;
5685 bool half_pixel_centers;
5686 ResizeBilinearOptionsT()
5687 : align_corners(false),
5688 half_pixel_centers(false) {
5689 }
5690};
5691
5692struct ResizeBilinearOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5693 typedef ResizeBilinearOptionsT NativeTableType;
5694 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5695 VT_ALIGN_CORNERS = 8,
5696 VT_HALF_PIXEL_CENTERS = 10
5697 };
5698 bool align_corners() const {
5699 return GetField<uint8_t>(VT_ALIGN_CORNERS, 0) != 0;
5700 }
5701 bool half_pixel_centers() const {
5702 return GetField<uint8_t>(VT_HALF_PIXEL_CENTERS, 0) != 0;
5703 }
5704 bool Verify(flatbuffers::Verifier &verifier) const {
5705 return VerifyTableStart(verifier) &&
5706 VerifyField<uint8_t>(verifier, VT_ALIGN_CORNERS) &&
5707 VerifyField<uint8_t>(verifier, VT_HALF_PIXEL_CENTERS) &&
5708 verifier.EndTable();
5709 }
5710 ResizeBilinearOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5711 void UnPackTo(ResizeBilinearOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5712 static flatbuffers::Offset<ResizeBilinearOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5713};
5714
5715struct ResizeBilinearOptionsBuilder {
5716 flatbuffers::FlatBufferBuilder &fbb_;
5717 flatbuffers::uoffset_t start_;
5718 void add_align_corners(bool align_corners) {
5719 fbb_.AddElement<uint8_t>(ResizeBilinearOptions::VT_ALIGN_CORNERS, static_cast<uint8_t>(align_corners), 0);
5720 }
5721 void add_half_pixel_centers(bool half_pixel_centers) {
5722 fbb_.AddElement<uint8_t>(ResizeBilinearOptions::VT_HALF_PIXEL_CENTERS, static_cast<uint8_t>(half_pixel_centers), 0);
5723 }
5724 explicit ResizeBilinearOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5725 : fbb_(_fbb) {
5726 start_ = fbb_.StartTable();
5727 }
5728 ResizeBilinearOptionsBuilder &operator=(const ResizeBilinearOptionsBuilder &);
5729 flatbuffers::Offset<ResizeBilinearOptions> Finish() {
5730 const auto end = fbb_.EndTable(start_);
5731 auto o = flatbuffers::Offset<ResizeBilinearOptions>(end);
5732 return o;
5733 }
5734};
5735
5736inline flatbuffers::Offset<ResizeBilinearOptions> CreateResizeBilinearOptions(
5737 flatbuffers::FlatBufferBuilder &_fbb,
5738 bool align_corners = false,
5739 bool half_pixel_centers = false) {
5740 ResizeBilinearOptionsBuilder builder_(_fbb);
5741 builder_.add_half_pixel_centers(half_pixel_centers);
5742 builder_.add_align_corners(align_corners);
5743 return builder_.Finish();
5744}
5745
5746flatbuffers::Offset<ResizeBilinearOptions> CreateResizeBilinearOptions(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5747
5748struct ResizeNearestNeighborOptionsT : public flatbuffers::NativeTable {
5749 typedef ResizeNearestNeighborOptions TableType;
5750 bool align_corners;
5751 bool half_pixel_centers;
5752 ResizeNearestNeighborOptionsT()
5753 : align_corners(false),
5754 half_pixel_centers(false) {
5755 }
5756};
5757
5758struct ResizeNearestNeighborOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5759 typedef ResizeNearestNeighborOptionsT NativeTableType;
5760 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5761 VT_ALIGN_CORNERS = 4,
5762 VT_HALF_PIXEL_CENTERS = 6
5763 };
5764 bool align_corners() const {
5765 return GetField<uint8_t>(VT_ALIGN_CORNERS, 0) != 0;
5766 }
5767 bool half_pixel_centers() const {
5768 return GetField<uint8_t>(VT_HALF_PIXEL_CENTERS, 0) != 0;
5769 }
5770 bool Verify(flatbuffers::Verifier &verifier) const {
5771 return VerifyTableStart(verifier) &&
5772 VerifyField<uint8_t>(verifier, VT_ALIGN_CORNERS) &&
5773 VerifyField<uint8_t>(verifier, VT_HALF_PIXEL_CENTERS) &&
5774 verifier.EndTable();
5775 }
5776 ResizeNearestNeighborOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5777 void UnPackTo(ResizeNearestNeighborOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5778 static flatbuffers::Offset<ResizeNearestNeighborOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5779};
5780
5781struct ResizeNearestNeighborOptionsBuilder {
5782 flatbuffers::FlatBufferBuilder &fbb_;
5783 flatbuffers::uoffset_t start_;
5784 void add_align_corners(bool align_corners) {
5785 fbb_.AddElement<uint8_t>(ResizeNearestNeighborOptions::VT_ALIGN_CORNERS, static_cast<uint8_t>(align_corners), 0);
5786 }
5787 void add_half_pixel_centers(bool half_pixel_centers) {
5788 fbb_.AddElement<uint8_t>(ResizeNearestNeighborOptions::VT_HALF_PIXEL_CENTERS, static_cast<uint8_t>(half_pixel_centers), 0);
5789 }
5790 explicit ResizeNearestNeighborOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5791 : fbb_(_fbb) {
5792 start_ = fbb_.StartTable();
5793 }
5794 ResizeNearestNeighborOptionsBuilder &operator=(const ResizeNearestNeighborOptionsBuilder &);
5795 flatbuffers::Offset<ResizeNearestNeighborOptions> Finish() {
5796 const auto end = fbb_.EndTable(start_);
5797 auto o = flatbuffers::Offset<ResizeNearestNeighborOptions>(end);
5798 return o;
5799 }
5800};
5801
5802inline flatbuffers::Offset<ResizeNearestNeighborOptions> CreateResizeNearestNeighborOptions(
5803 flatbuffers::FlatBufferBuilder &_fbb,
5804 bool align_corners = false,
5805 bool half_pixel_centers = false) {
5806 ResizeNearestNeighborOptionsBuilder builder_(_fbb);
5807 builder_.add_half_pixel_centers(half_pixel_centers);
5808 builder_.add_align_corners(align_corners);
5809 return builder_.Finish();
5810}
5811
5812flatbuffers::Offset<ResizeNearestNeighborOptions> CreateResizeNearestNeighborOptions(flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5813
5814struct CallOptionsT : public flatbuffers::NativeTable {
5815 typedef CallOptions TableType;
5816 uint32_t subgraph;
5817 CallOptionsT()
5818 : subgraph(0) {
5819 }
5820};
5821
5822struct CallOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5823 typedef CallOptionsT NativeTableType;
5824 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5825 VT_SUBGRAPH = 4
5826 };
5827 uint32_t subgraph() const {
5828 return GetField<uint32_t>(VT_SUBGRAPH, 0);
5829 }
5830 bool Verify(flatbuffers::Verifier &verifier) const {
5831 return VerifyTableStart(verifier) &&
5832 VerifyField<uint32_t>(verifier, VT_SUBGRAPH) &&
5833 verifier.EndTable();
5834 }
5835 CallOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5836 void UnPackTo(CallOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5837 static flatbuffers::Offset<CallOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5838};
5839
5840struct CallOptionsBuilder {
5841 flatbuffers::FlatBufferBuilder &fbb_;
5842 flatbuffers::uoffset_t start_;
5843 void add_subgraph(uint32_t subgraph) {
5844 fbb_.AddElement<uint32_t>(CallOptions::VT_SUBGRAPH, subgraph, 0);
5845 }
5846 explicit CallOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5847 : fbb_(_fbb) {
5848 start_ = fbb_.StartTable();
5849 }
5850 CallOptionsBuilder &operator=(const CallOptionsBuilder &);
5851 flatbuffers::Offset<CallOptions> Finish() {
5852 const auto end = fbb_.EndTable(start_);
5853 auto o = flatbuffers::Offset<CallOptions>(end);
5854 return o;
5855 }
5856};
5857
5858inline flatbuffers::Offset<CallOptions> CreateCallOptions(
5859 flatbuffers::FlatBufferBuilder &_fbb,
5860 uint32_t subgraph = 0) {
5861 CallOptionsBuilder builder_(_fbb);
5862 builder_.add_subgraph(subgraph);
5863 return builder_.Finish();
5864}
5865
5866flatbuffers::Offset<CallOptions> CreateCallOptions(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5867
5868struct PadOptionsT : public flatbuffers::NativeTable {
5869 typedef PadOptions TableType;
5870 PadOptionsT() {
5871 }
5872};
5873
5874struct PadOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5875 typedef PadOptionsT NativeTableType;
5876 bool Verify(flatbuffers::Verifier &verifier) const {
5877 return VerifyTableStart(verifier) &&
5878 verifier.EndTable();
5879 }
5880 PadOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5881 void UnPackTo(PadOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5882 static flatbuffers::Offset<PadOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5883};
5884
5885struct PadOptionsBuilder {
5886 flatbuffers::FlatBufferBuilder &fbb_;
5887 flatbuffers::uoffset_t start_;
5888 explicit PadOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5889 : fbb_(_fbb) {
5890 start_ = fbb_.StartTable();
5891 }
5892 PadOptionsBuilder &operator=(const PadOptionsBuilder &);
5893 flatbuffers::Offset<PadOptions> Finish() {
5894 const auto end = fbb_.EndTable(start_);
5895 auto o = flatbuffers::Offset<PadOptions>(end);
5896 return o;
5897 }
5898};
5899
5900inline flatbuffers::Offset<PadOptions> CreatePadOptions(
5901 flatbuffers::FlatBufferBuilder &_fbb) {
5902 PadOptionsBuilder builder_(_fbb);
5903 return builder_.Finish();
5904}
5905
5906flatbuffers::Offset<PadOptions> CreatePadOptions(flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5907
5908struct PadV2OptionsT : public flatbuffers::NativeTable {
5909 typedef PadV2Options TableType;
5910 PadV2OptionsT() {
5911 }
5912};
5913
5914struct PadV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5915 typedef PadV2OptionsT NativeTableType;
5916 bool Verify(flatbuffers::Verifier &verifier) const {
5917 return VerifyTableStart(verifier) &&
5918 verifier.EndTable();
5919 }
5920 PadV2OptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5921 void UnPackTo(PadV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5922 static flatbuffers::Offset<PadV2Options> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5923};
5924
5925struct PadV2OptionsBuilder {
5926 flatbuffers::FlatBufferBuilder &fbb_;
5927 flatbuffers::uoffset_t start_;
5928 explicit PadV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5929 : fbb_(_fbb) {
5930 start_ = fbb_.StartTable();
5931 }
5932 PadV2OptionsBuilder &operator=(const PadV2OptionsBuilder &);
5933 flatbuffers::Offset<PadV2Options> Finish() {
5934 const auto end = fbb_.EndTable(start_);
5935 auto o = flatbuffers::Offset<PadV2Options>(end);
5936 return o;
5937 }
5938};
5939
5940inline flatbuffers::Offset<PadV2Options> CreatePadV2Options(
5941 flatbuffers::FlatBufferBuilder &_fbb) {
5942 PadV2OptionsBuilder builder_(_fbb);
5943 return builder_.Finish();
5944}
5945
5946flatbuffers::Offset<PadV2Options> CreatePadV2Options(flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5947
5948struct ReshapeOptionsT : public flatbuffers::NativeTable {
5949 typedef ReshapeOptions TableType;
5950 std::vector<int32_t> new_shape;
5951 ReshapeOptionsT() {
5952 }
5953};
5954
5955struct ReshapeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5956 typedef ReshapeOptionsT NativeTableType;
5957 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5958 VT_NEW_SHAPE = 4
5959 };
5960 const flatbuffers::Vector<int32_t> *new_shape() const {
5961 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_NEW_SHAPE);
5962 }
5963 bool Verify(flatbuffers::Verifier &verifier) const {
5964 return VerifyTableStart(verifier) &&
5965 VerifyOffset(verifier, VT_NEW_SHAPE) &&
5966 verifier.VerifyVector(new_shape()) &&
5967 verifier.EndTable();
5968 }
5969 ReshapeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5970 void UnPackTo(ReshapeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5971 static flatbuffers::Offset<ReshapeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5972};
5973
5974struct ReshapeOptionsBuilder {
5975 flatbuffers::FlatBufferBuilder &fbb_;
5976 flatbuffers::uoffset_t start_;
5977 void add_new_shape(flatbuffers::Offset<flatbuffers::Vector<int32_t>> new_shape) {
5978 fbb_.AddOffset(ReshapeOptions::VT_NEW_SHAPE, new_shape);
5979 }
5980 explicit ReshapeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5981 : fbb_(_fbb) {
5982 start_ = fbb_.StartTable();
5983 }
5984 ReshapeOptionsBuilder &operator=(const ReshapeOptionsBuilder &);
5985 flatbuffers::Offset<ReshapeOptions> Finish() {
5986 const auto end = fbb_.EndTable(start_);
5987 auto o = flatbuffers::Offset<ReshapeOptions>(end);
5988 return o;
5989 }
5990};
5991
5992inline flatbuffers::Offset<ReshapeOptions> CreateReshapeOptions(
5993 flatbuffers::FlatBufferBuilder &_fbb,
5994 flatbuffers::Offset<flatbuffers::Vector<int32_t>> new_shape = 0) {
5995 ReshapeOptionsBuilder builder_(_fbb);
5996 builder_.add_new_shape(new_shape);
5997 return builder_.Finish();
5998}
5999
6000inline flatbuffers::Offset<ReshapeOptions> CreateReshapeOptionsDirect(
6001 flatbuffers::FlatBufferBuilder &_fbb,
6002 const std::vector<int32_t> *new_shape = nullptr) {
6003 auto new_shape__ = new_shape ? _fbb.CreateVector<int32_t>(*new_shape) : 0;
6004 return tflite::CreateReshapeOptions(
6005 _fbb,
6006 new_shape__);
6007}
6008
6009flatbuffers::Offset<ReshapeOptions> CreateReshapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6010
6011struct SpaceToBatchNDOptionsT : public flatbuffers::NativeTable {
6012 typedef SpaceToBatchNDOptions TableType;
6013 SpaceToBatchNDOptionsT() {
6014 }
6015};
6016
6017struct SpaceToBatchNDOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6018 typedef SpaceToBatchNDOptionsT NativeTableType;
6019 bool Verify(flatbuffers::Verifier &verifier) const {
6020 return VerifyTableStart(verifier) &&
6021 verifier.EndTable();
6022 }
6023 SpaceToBatchNDOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6024 void UnPackTo(SpaceToBatchNDOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6025 static flatbuffers::Offset<SpaceToBatchNDOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6026};
6027
6028struct SpaceToBatchNDOptionsBuilder {
6029 flatbuffers::FlatBufferBuilder &fbb_;
6030 flatbuffers::uoffset_t start_;
6031 explicit SpaceToBatchNDOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6032 : fbb_(_fbb) {
6033 start_ = fbb_.StartTable();
6034 }
6035 SpaceToBatchNDOptionsBuilder &operator=(const SpaceToBatchNDOptionsBuilder &);
6036 flatbuffers::Offset<SpaceToBatchNDOptions> Finish() {
6037 const auto end = fbb_.EndTable(start_);
6038 auto o = flatbuffers::Offset<SpaceToBatchNDOptions>(end);
6039 return o;
6040 }
6041};
6042
6043inline flatbuffers::Offset<SpaceToBatchNDOptions> CreateSpaceToBatchNDOptions(
6044 flatbuffers::FlatBufferBuilder &_fbb) {
6045 SpaceToBatchNDOptionsBuilder builder_(_fbb);
6046 return builder_.Finish();
6047}
6048
6049flatbuffers::Offset<SpaceToBatchNDOptions> CreateSpaceToBatchNDOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6050
6051struct BatchToSpaceNDOptionsT : public flatbuffers::NativeTable {
6052 typedef BatchToSpaceNDOptions TableType;
6053 BatchToSpaceNDOptionsT() {
6054 }
6055};
6056
6057struct BatchToSpaceNDOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6058 typedef BatchToSpaceNDOptionsT NativeTableType;
6059 bool Verify(flatbuffers::Verifier &verifier) const {
6060 return VerifyTableStart(verifier) &&
6061 verifier.EndTable();
6062 }
6063 BatchToSpaceNDOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6064 void UnPackTo(BatchToSpaceNDOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6065 static flatbuffers::Offset<BatchToSpaceNDOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6066};
6067
6068struct BatchToSpaceNDOptionsBuilder {
6069 flatbuffers::FlatBufferBuilder &fbb_;
6070 flatbuffers::uoffset_t start_;
6071 explicit BatchToSpaceNDOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6072 : fbb_(_fbb) {
6073 start_ = fbb_.StartTable();
6074 }
6075 BatchToSpaceNDOptionsBuilder &operator=(const BatchToSpaceNDOptionsBuilder &);
6076 flatbuffers::Offset<BatchToSpaceNDOptions> Finish() {
6077 const auto end = fbb_.EndTable(start_);
6078 auto o = flatbuffers::Offset<BatchToSpaceNDOptions>(end);
6079 return o;
6080 }
6081};
6082
6083inline flatbuffers::Offset<BatchToSpaceNDOptions> CreateBatchToSpaceNDOptions(
6084 flatbuffers::FlatBufferBuilder &_fbb) {
6085 BatchToSpaceNDOptionsBuilder builder_(_fbb);
6086 return builder_.Finish();
6087}
6088
6089flatbuffers::Offset<BatchToSpaceNDOptions> CreateBatchToSpaceNDOptions(flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6090
6091struct SkipGramOptionsT : public flatbuffers::NativeTable {
6092 typedef SkipGramOptions TableType;
6093 int32_t ngram_size;
6094 int32_t max_skip_size;
6095 bool include_all_ngrams;
6096 SkipGramOptionsT()
6097 : ngram_size(0),
6098 max_skip_size(0),
6099 include_all_ngrams(false) {
6100 }
6101};
6102
6103struct SkipGramOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6104 typedef SkipGramOptionsT NativeTableType;
6105 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6106 VT_NGRAM_SIZE = 4,
6107 VT_MAX_SKIP_SIZE = 6,
6108 VT_INCLUDE_ALL_NGRAMS = 8
6109 };
6110 int32_t ngram_size() const {
6111 return GetField<int32_t>(VT_NGRAM_SIZE, 0);
6112 }
6113 int32_t max_skip_size() const {
6114 return GetField<int32_t>(VT_MAX_SKIP_SIZE, 0);
6115 }
6116 bool include_all_ngrams() const {
6117 return GetField<uint8_t>(VT_INCLUDE_ALL_NGRAMS, 0) != 0;
6118 }
6119 bool Verify(flatbuffers::Verifier &verifier) const {
6120 return VerifyTableStart(verifier) &&
6121 VerifyField<int32_t>(verifier, VT_NGRAM_SIZE) &&
6122 VerifyField<int32_t>(verifier, VT_MAX_SKIP_SIZE) &&
6123 VerifyField<uint8_t>(verifier, VT_INCLUDE_ALL_NGRAMS) &&
6124 verifier.EndTable();
6125 }
6126 SkipGramOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6127 void UnPackTo(SkipGramOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6128 static flatbuffers::Offset<SkipGramOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6129};
6130
6131struct SkipGramOptionsBuilder {
6132 flatbuffers::FlatBufferBuilder &fbb_;
6133 flatbuffers::uoffset_t start_;
6134 void add_ngram_size(int32_t ngram_size) {
6135 fbb_.AddElement<int32_t>(SkipGramOptions::VT_NGRAM_SIZE, ngram_size, 0);
6136 }
6137 void add_max_skip_size(int32_t max_skip_size) {
6138 fbb_.AddElement<int32_t>(SkipGramOptions::VT_MAX_SKIP_SIZE, max_skip_size, 0);
6139 }
6140 void add_include_all_ngrams(bool include_all_ngrams) {
6141 fbb_.AddElement<uint8_t>(SkipGramOptions::VT_INCLUDE_ALL_NGRAMS, static_cast<uint8_t>(include_all_ngrams), 0);
6142 }
6143 explicit SkipGramOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6144 : fbb_(_fbb) {
6145 start_ = fbb_.StartTable();
6146 }
6147 SkipGramOptionsBuilder &operator=(const SkipGramOptionsBuilder &);
6148 flatbuffers::Offset<SkipGramOptions> Finish() {
6149 const auto end = fbb_.EndTable(start_);
6150 auto o = flatbuffers::Offset<SkipGramOptions>(end);
6151 return o;
6152 }
6153};
6154
6155inline flatbuffers::Offset<SkipGramOptions> CreateSkipGramOptions(
6156 flatbuffers::FlatBufferBuilder &_fbb,
6157 int32_t ngram_size = 0,
6158 int32_t max_skip_size = 0,
6159 bool include_all_ngrams = false) {
6160 SkipGramOptionsBuilder builder_(_fbb);
6161 builder_.add_max_skip_size(max_skip_size);
6162 builder_.add_ngram_size(ngram_size);
6163 builder_.add_include_all_ngrams(include_all_ngrams);
6164 return builder_.Finish();
6165}
6166
6167flatbuffers::Offset<SkipGramOptions> CreateSkipGramOptions(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6168
6169struct SpaceToDepthOptionsT : public flatbuffers::NativeTable {
6170 typedef SpaceToDepthOptions TableType;
6171 int32_t block_size;
6172 SpaceToDepthOptionsT()
6173 : block_size(0) {
6174 }
6175};
6176
6177struct SpaceToDepthOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6178 typedef SpaceToDepthOptionsT NativeTableType;
6179 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6180 VT_BLOCK_SIZE = 4
6181 };
6182 int32_t block_size() const {
6183 return GetField<int32_t>(VT_BLOCK_SIZE, 0);
6184 }
6185 bool Verify(flatbuffers::Verifier &verifier) const {
6186 return VerifyTableStart(verifier) &&
6187 VerifyField<int32_t>(verifier, VT_BLOCK_SIZE) &&
6188 verifier.EndTable();
6189 }
6190 SpaceToDepthOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6191 void UnPackTo(SpaceToDepthOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6192 static flatbuffers::Offset<SpaceToDepthOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6193};
6194
6195struct SpaceToDepthOptionsBuilder {
6196 flatbuffers::FlatBufferBuilder &fbb_;
6197 flatbuffers::uoffset_t start_;
6198 void add_block_size(int32_t block_size) {
6199 fbb_.AddElement<int32_t>(SpaceToDepthOptions::VT_BLOCK_SIZE, block_size, 0);
6200 }
6201 explicit SpaceToDepthOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6202 : fbb_(_fbb) {
6203 start_ = fbb_.StartTable();
6204 }
6205 SpaceToDepthOptionsBuilder &operator=(const SpaceToDepthOptionsBuilder &);
6206 flatbuffers::Offset<SpaceToDepthOptions> Finish() {
6207 const auto end = fbb_.EndTable(start_);
6208 auto o = flatbuffers::Offset<SpaceToDepthOptions>(end);
6209 return o;
6210 }
6211};
6212
6213inline flatbuffers::Offset<SpaceToDepthOptions> CreateSpaceToDepthOptions(
6214 flatbuffers::FlatBufferBuilder &_fbb,
6215 int32_t block_size = 0) {
6216 SpaceToDepthOptionsBuilder builder_(_fbb);
6217 builder_.add_block_size(block_size);
6218 return builder_.Finish();
6219}
6220
6221flatbuffers::Offset<SpaceToDepthOptions> CreateSpaceToDepthOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6222
6223struct DepthToSpaceOptionsT : public flatbuffers::NativeTable {
6224 typedef DepthToSpaceOptions TableType;
6225 int32_t block_size;
6226 DepthToSpaceOptionsT()
6227 : block_size(0) {
6228 }
6229};
6230
6231struct DepthToSpaceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6232 typedef DepthToSpaceOptionsT NativeTableType;
6233 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6234 VT_BLOCK_SIZE = 4
6235 };
6236 int32_t block_size() const {
6237 return GetField<int32_t>(VT_BLOCK_SIZE, 0);
6238 }
6239 bool Verify(flatbuffers::Verifier &verifier) const {
6240 return VerifyTableStart(verifier) &&
6241 VerifyField<int32_t>(verifier, VT_BLOCK_SIZE) &&
6242 verifier.EndTable();
6243 }
6244 DepthToSpaceOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6245 void UnPackTo(DepthToSpaceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6246 static flatbuffers::Offset<DepthToSpaceOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DepthToSpaceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6247};
6248
6249struct DepthToSpaceOptionsBuilder {
6250 flatbuffers::FlatBufferBuilder &fbb_;
6251 flatbuffers::uoffset_t start_;
6252 void add_block_size(int32_t block_size) {
6253 fbb_.AddElement<int32_t>(DepthToSpaceOptions::VT_BLOCK_SIZE, block_size, 0);
6254 }
6255 explicit DepthToSpaceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6256 : fbb_(_fbb) {
6257 start_ = fbb_.StartTable();
6258 }
6259 DepthToSpaceOptionsBuilder &operator=(const DepthToSpaceOptionsBuilder &);
6260 flatbuffers::Offset<DepthToSpaceOptions> Finish() {
6261 const auto end = fbb_.EndTable(start_);
6262 auto o = flatbuffers::Offset<DepthToSpaceOptions>(end);
6263 return o;
6264 }
6265};
6266
6267inline flatbuffers::Offset<DepthToSpaceOptions> CreateDepthToSpaceOptions(
6268 flatbuffers::FlatBufferBuilder &_fbb,
6269 int32_t block_size = 0) {
6270 DepthToSpaceOptionsBuilder builder_(_fbb);
6271 builder_.add_block_size(block_size);
6272 return builder_.Finish();
6273}
6274
6275flatbuffers::Offset<DepthToSpaceOptions> CreateDepthToSpaceOptions(flatbuffers::FlatBufferBuilder &_fbb, const DepthToSpaceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6276
6277struct SubOptionsT : public flatbuffers::NativeTable {
6278 typedef SubOptions TableType;
6279 tflite::ActivationFunctionType fused_activation_function;
6280 bool pot_scale_int16;
6281 SubOptionsT()
6282 : fused_activation_function(tflite::ActivationFunctionType_NONE),
6283 pot_scale_int16(true) {
6284 }
6285};
6286
6287struct SubOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6288 typedef SubOptionsT NativeTableType;
6289 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6290 VT_FUSED_ACTIVATION_FUNCTION = 4,
6291 VT_POT_SCALE_INT16 = 6
6292 };
6293 tflite::ActivationFunctionType fused_activation_function() const {
6294 return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
6295 }
6296 bool pot_scale_int16() const {
6297 return GetField<uint8_t>(VT_POT_SCALE_INT16, 1) != 0;
6298 }
6299 bool Verify(flatbuffers::Verifier &verifier) const {
6300 return VerifyTableStart(verifier) &&
6301 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
6302 VerifyField<uint8_t>(verifier, VT_POT_SCALE_INT16) &&
6303 verifier.EndTable();
6304 }
6305 SubOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6306 void UnPackTo(SubOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6307 static flatbuffers::Offset<SubOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6308};
6309
6310struct SubOptionsBuilder {
6311 flatbuffers::FlatBufferBuilder &fbb_;
6312 flatbuffers::uoffset_t start_;
6313 void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
6314 fbb_.AddElement<int8_t>(SubOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
6315 }
6316 void add_pot_scale_int16(bool pot_scale_int16) {
6317 fbb_.AddElement<uint8_t>(SubOptions::VT_POT_SCALE_INT16, static_cast<uint8_t>(pot_scale_int16), 1);
6318 }
6319 explicit SubOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6320 : fbb_(_fbb) {
6321 start_ = fbb_.StartTable();
6322 }
6323 SubOptionsBuilder &operator=(const SubOptionsBuilder &);
6324 flatbuffers::Offset<SubOptions> Finish() {
6325 const auto end = fbb_.EndTable(start_);
6326 auto o = flatbuffers::Offset<SubOptions>(end);
6327 return o;
6328 }
6329};
6330
6331inline flatbuffers::Offset<SubOptions> CreateSubOptions(
6332 flatbuffers::FlatBufferBuilder &_fbb,
6333 tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
6334 bool pot_scale_int16 = true) {
6335 SubOptionsBuilder builder_(_fbb);
6336 builder_.add_pot_scale_int16(pot_scale_int16);
6337 builder_.add_fused_activation_function(fused_activation_function);
6338 return builder_.Finish();
6339}
6340
6341flatbuffers::Offset<SubOptions> CreateSubOptions(flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6342
6343struct DivOptionsT : public flatbuffers::NativeTable {
6344 typedef DivOptions TableType;
6345 tflite::ActivationFunctionType fused_activation_function;
6346 DivOptionsT()
6347 : fused_activation_function(tflite::ActivationFunctionType_NONE) {
6348 }
6349};
6350
6351struct DivOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6352 typedef DivOptionsT NativeTableType;
6353 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6354 VT_FUSED_ACTIVATION_FUNCTION = 4
6355 };
6356 tflite::ActivationFunctionType fused_activation_function() const {
6357 return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
6358 }
6359 bool Verify(flatbuffers::Verifier &verifier) const {
6360 return VerifyTableStart(verifier) &&
6361 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
6362 verifier.EndTable();
6363 }
6364 DivOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6365 void UnPackTo(DivOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6366 static flatbuffers::Offset<DivOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6367};
6368
6369struct DivOptionsBuilder {
6370 flatbuffers::FlatBufferBuilder &fbb_;
6371 flatbuffers::uoffset_t start_;
6372 void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
6373 fbb_.AddElement<int8_t>(DivOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
6374 }
6375 explicit DivOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6376 : fbb_(_fbb) {
6377 start_ = fbb_.StartTable();
6378 }
6379 DivOptionsBuilder &operator=(const DivOptionsBuilder &);
6380 flatbuffers::Offset<DivOptions> Finish() {
6381 const auto end = fbb_.EndTable(start_);
6382 auto o = flatbuffers::Offset<DivOptions>(end);
6383 return o;
6384 }
6385};
6386
6387inline flatbuffers::Offset<DivOptions> CreateDivOptions(
6388 flatbuffers::FlatBufferBuilder &_fbb,
6389 tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE) {
6390 DivOptionsBuilder builder_(_fbb);
6391 builder_.add_fused_activation_function(fused_activation_function);
6392 return builder_.Finish();
6393}
6394
6395flatbuffers::Offset<DivOptions> CreateDivOptions(flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6396
6397struct TopKV2OptionsT : public flatbuffers::NativeTable {
6398 typedef TopKV2Options TableType;
6399 TopKV2OptionsT() {
6400 }
6401};
6402
6403struct TopKV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6404 typedef TopKV2OptionsT NativeTableType;
6405 bool Verify(flatbuffers::Verifier &verifier) const {
6406 return VerifyTableStart(verifier) &&
6407 verifier.EndTable();
6408 }
6409 TopKV2OptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6410 void UnPackTo(TopKV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6411 static flatbuffers::Offset<TopKV2Options> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6412};
6413
6414struct TopKV2OptionsBuilder {
6415 flatbuffers::FlatBufferBuilder &fbb_;
6416 flatbuffers::uoffset_t start_;
6417 explicit TopKV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6418 : fbb_(_fbb) {
6419 start_ = fbb_.StartTable();
6420 }
6421 TopKV2OptionsBuilder &operator=(const TopKV2OptionsBuilder &);
6422 flatbuffers::Offset<TopKV2Options> Finish() {
6423 const auto end = fbb_.EndTable(start_);
6424 auto o = flatbuffers::Offset<TopKV2Options>(end);
6425 return o;
6426 }
6427};
6428
6429inline flatbuffers::Offset<TopKV2Options> CreateTopKV2Options(
6430 flatbuffers::FlatBufferBuilder &_fbb) {
6431 TopKV2OptionsBuilder builder_(_fbb);
6432 return builder_.Finish();
6433}
6434
6435flatbuffers::Offset<TopKV2Options> CreateTopKV2Options(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6436
6437struct EmbeddingLookupSparseOptionsT : public flatbuffers::NativeTable {
6438 typedef EmbeddingLookupSparseOptions TableType;
6439 tflite::CombinerType combiner;
6440 EmbeddingLookupSparseOptionsT()
6441 : combiner(tflite::CombinerType_SUM) {
6442 }
6443};
6444
6445struct EmbeddingLookupSparseOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6446 typedef EmbeddingLookupSparseOptionsT NativeTableType;
6447 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6448 VT_COMBINER = 4
6449 };
6450 tflite::CombinerType combiner() const {
6451 return static_cast<tflite::CombinerType>(GetField<int8_t>(VT_COMBINER, 0));
6452 }
6453 bool Verify(flatbuffers::Verifier &verifier) const {
6454 return VerifyTableStart(verifier) &&
6455 VerifyField<int8_t>(verifier, VT_COMBINER) &&
6456 verifier.EndTable();
6457 }
6458 EmbeddingLookupSparseOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6459 void UnPackTo(EmbeddingLookupSparseOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6460 static flatbuffers::Offset<EmbeddingLookupSparseOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6461};
6462
6463struct EmbeddingLookupSparseOptionsBuilder {
6464 flatbuffers::FlatBufferBuilder &fbb_;
6465 flatbuffers::uoffset_t start_;
6466 void add_combiner(tflite::CombinerType combiner) {
6467 fbb_.AddElement<int8_t>(EmbeddingLookupSparseOptions::VT_COMBINER, static_cast<int8_t>(combiner), 0);
6468 }
6469 explicit EmbeddingLookupSparseOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6470 : fbb_(_fbb) {
6471 start_ = fbb_.StartTable();
6472 }
6473 EmbeddingLookupSparseOptionsBuilder &operator=(const EmbeddingLookupSparseOptionsBuilder &);
6474 flatbuffers::Offset<EmbeddingLookupSparseOptions> Finish() {
6475 const auto end = fbb_.EndTable(start_);
6476 auto o = flatbuffers::Offset<EmbeddingLookupSparseOptions>(end);
6477 return o;
6478 }
6479};
6480
6481inline flatbuffers::Offset<EmbeddingLookupSparseOptions> CreateEmbeddingLookupSparseOptions(
6482 flatbuffers::FlatBufferBuilder &_fbb,
6483 tflite::CombinerType combiner = tflite::CombinerType_SUM) {
6484 EmbeddingLookupSparseOptionsBuilder builder_(_fbb);
6485 builder_.add_combiner(combiner);
6486 return builder_.Finish();
6487}
6488
6489flatbuffers::Offset<EmbeddingLookupSparseOptions> CreateEmbeddingLookupSparseOptions(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6490
6491struct GatherOptionsT : public flatbuffers::NativeTable {
6492 typedef GatherOptions TableType;
6493 int32_t axis;
6494 int32_t batch_dims;
6495 GatherOptionsT()
6496 : axis(0),
6497 batch_dims(0) {
6498 }
6499};
6500
6501struct GatherOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6502 typedef GatherOptionsT NativeTableType;
6503 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6504 VT_AXIS = 4,
6505 VT_BATCH_DIMS = 6
6506 };
6507 int32_t axis() const {
6508 return GetField<int32_t>(VT_AXIS, 0);
6509 }
6510 int32_t batch_dims() const {
6511 return GetField<int32_t>(VT_BATCH_DIMS, 0);
6512 }
6513 bool Verify(flatbuffers::Verifier &verifier) const {
6514 return VerifyTableStart(verifier) &&
6515 VerifyField<int32_t>(verifier, VT_AXIS) &&
6516 VerifyField<int32_t>(verifier, VT_BATCH_DIMS) &&
6517 verifier.EndTable();
6518 }
6519 GatherOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6520 void UnPackTo(GatherOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6521 static flatbuffers::Offset<GatherOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6522};
6523
6524struct GatherOptionsBuilder {
6525 flatbuffers::FlatBufferBuilder &fbb_;
6526 flatbuffers::uoffset_t start_;
6527 void add_axis(int32_t axis) {
6528 fbb_.AddElement<int32_t>(GatherOptions::VT_AXIS, axis, 0);
6529 }
6530 void add_batch_dims(int32_t batch_dims) {
6531 fbb_.AddElement<int32_t>(GatherOptions::VT_BATCH_DIMS, batch_dims, 0);
6532 }
6533 explicit GatherOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6534 : fbb_(_fbb) {
6535 start_ = fbb_.StartTable();
6536 }
6537 GatherOptionsBuilder &operator=(const GatherOptionsBuilder &);
6538 flatbuffers::Offset<GatherOptions> Finish() {
6539 const auto end = fbb_.EndTable(start_);
6540 auto o = flatbuffers::Offset<GatherOptions>(end);
6541 return o;
6542 }
6543};
6544
6545inline flatbuffers::Offset<GatherOptions> CreateGatherOptions(
6546 flatbuffers::FlatBufferBuilder &_fbb,
6547 int32_t axis = 0,
6548 int32_t batch_dims = 0) {
6549 GatherOptionsBuilder builder_(_fbb);
6550 builder_.add_batch_dims(batch_dims);
6551 builder_.add_axis(axis);
6552 return builder_.Finish();
6553}
6554
6555flatbuffers::Offset<GatherOptions> CreateGatherOptions(flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6556
6557struct TransposeOptionsT : public flatbuffers::NativeTable {
6558 typedef TransposeOptions TableType;
6559 TransposeOptionsT() {
6560 }
6561};
6562
6563struct TransposeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6564 typedef TransposeOptionsT NativeTableType;
6565 bool Verify(flatbuffers::Verifier &verifier) const {
6566 return VerifyTableStart(verifier) &&
6567 verifier.EndTable();
6568 }
6569 TransposeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6570 void UnPackTo(TransposeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6571 static flatbuffers::Offset<TransposeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6572};
6573
6574struct TransposeOptionsBuilder {
6575 flatbuffers::FlatBufferBuilder &fbb_;
6576 flatbuffers::uoffset_t start_;
6577 explicit TransposeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6578 : fbb_(_fbb) {
6579 start_ = fbb_.StartTable();
6580 }
6581 TransposeOptionsBuilder &operator=(const TransposeOptionsBuilder &);
6582 flatbuffers::Offset<TransposeOptions> Finish() {
6583 const auto end = fbb_.EndTable(start_);
6584 auto o = flatbuffers::Offset<TransposeOptions>(end);
6585 return o;
6586 }
6587};
6588
6589inline flatbuffers::Offset<TransposeOptions> CreateTransposeOptions(
6590 flatbuffers::FlatBufferBuilder &_fbb) {
6591 TransposeOptionsBuilder builder_(_fbb);
6592 return builder_.Finish();
6593}
6594
6595flatbuffers::Offset<TransposeOptions> CreateTransposeOptions(flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6596
6597struct ExpOptionsT : public flatbuffers::NativeTable {
6598 typedef ExpOptions TableType;
6599 ExpOptionsT() {
6600 }
6601};
6602
6603struct ExpOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6604 typedef ExpOptionsT NativeTableType;
6605 bool Verify(flatbuffers::Verifier &verifier) const {
6606 return VerifyTableStart(verifier) &&
6607 verifier.EndTable();
6608 }
6609 ExpOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6610 void UnPackTo(ExpOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6611 static flatbuffers::Offset<ExpOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6612};
6613
6614struct ExpOptionsBuilder {
6615 flatbuffers::FlatBufferBuilder &fbb_;
6616 flatbuffers::uoffset_t start_;
6617 explicit ExpOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6618 : fbb_(_fbb) {
6619 start_ = fbb_.StartTable();
6620 }
6621 ExpOptionsBuilder &operator=(const ExpOptionsBuilder &);
6622 flatbuffers::Offset<ExpOptions> Finish() {
6623 const auto end = fbb_.EndTable(start_);
6624 auto o = flatbuffers::Offset<ExpOptions>(end);
6625 return o;
6626 }
6627};
6628
6629inline flatbuffers::Offset<ExpOptions> CreateExpOptions(
6630 flatbuffers::FlatBufferBuilder &_fbb) {
6631 ExpOptionsBuilder builder_(_fbb);
6632 return builder_.Finish();
6633}
6634
6635flatbuffers::Offset<ExpOptions> CreateExpOptions(flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6636
6637struct CosOptionsT : public flatbuffers::NativeTable {
6638 typedef CosOptions TableType;
6639 CosOptionsT() {
6640 }
6641};
6642
6643struct CosOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6644 typedef CosOptionsT NativeTableType;
6645 bool Verify(flatbuffers::Verifier &verifier) const {
6646 return VerifyTableStart(verifier) &&
6647 verifier.EndTable();
6648 }
6649 CosOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6650 void UnPackTo(CosOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6651 static flatbuffers::Offset<CosOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6652};
6653
6654struct CosOptionsBuilder {
6655 flatbuffers::FlatBufferBuilder &fbb_;
6656 flatbuffers::uoffset_t start_;
6657 explicit CosOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6658 : fbb_(_fbb) {
6659 start_ = fbb_.StartTable();
6660 }
6661 CosOptionsBuilder &operator=(const CosOptionsBuilder &);
6662 flatbuffers::Offset<CosOptions> Finish() {
6663 const auto end = fbb_.EndTable(start_);
6664 auto o = flatbuffers::Offset<CosOptions>(end);
6665 return o;
6666 }
6667};
6668
6669inline flatbuffers::Offset<CosOptions> CreateCosOptions(
6670 flatbuffers::FlatBufferBuilder &_fbb) {
6671 CosOptionsBuilder builder_(_fbb);
6672 return builder_.Finish();
6673}
6674
6675flatbuffers::Offset<CosOptions> CreateCosOptions(flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6676
6677struct ReducerOptionsT : public flatbuffers::NativeTable {
6678 typedef ReducerOptions TableType;
6679 bool keep_dims;
6680 ReducerOptionsT()
6681 : keep_dims(false) {
6682 }
6683};
6684
6685struct ReducerOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6686 typedef ReducerOptionsT NativeTableType;
6687 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6688 VT_KEEP_DIMS = 4
6689 };
6690 bool keep_dims() const {
6691 return GetField<uint8_t>(VT_KEEP_DIMS, 0) != 0;
6692 }
6693 bool Verify(flatbuffers::Verifier &verifier) const {
6694 return VerifyTableStart(verifier) &&
6695 VerifyField<uint8_t>(verifier, VT_KEEP_DIMS) &&
6696 verifier.EndTable();
6697 }
6698 ReducerOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6699 void UnPackTo(ReducerOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6700 static flatbuffers::Offset<ReducerOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6701};
6702
6703struct ReducerOptionsBuilder {
6704 flatbuffers::FlatBufferBuilder &fbb_;
6705 flatbuffers::uoffset_t start_;
6706 void add_keep_dims(bool keep_dims) {
6707 fbb_.AddElement<uint8_t>(ReducerOptions::VT_KEEP_DIMS, static_cast<uint8_t>(keep_dims), 0);
6708 }
6709 explicit ReducerOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6710 : fbb_(_fbb) {
6711 start_ = fbb_.StartTable();
6712 }
6713 ReducerOptionsBuilder &operator=(const ReducerOptionsBuilder &);
6714 flatbuffers::Offset<ReducerOptions> Finish() {
6715 const auto end = fbb_.EndTable(start_);
6716 auto o = flatbuffers::Offset<ReducerOptions>(end);
6717 return o;
6718 }
6719};
6720
6721inline flatbuffers::Offset<ReducerOptions> CreateReducerOptions(
6722 flatbuffers::FlatBufferBuilder &_fbb,
6723 bool keep_dims = false) {
6724 ReducerOptionsBuilder builder_(_fbb);
6725 builder_.add_keep_dims(keep_dims);
6726 return builder_.Finish();
6727}
6728
6729flatbuffers::Offset<ReducerOptions> CreateReducerOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6730
6731struct SqueezeOptionsT : public flatbuffers::NativeTable {
6732 typedef SqueezeOptions TableType;
6733 std::vector<int32_t> squeeze_dims;
6734 SqueezeOptionsT() {
6735 }
6736};
6737
6738struct SqueezeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6739 typedef SqueezeOptionsT NativeTableType;
6740 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6741 VT_SQUEEZE_DIMS = 4
6742 };
6743 const flatbuffers::Vector<int32_t> *squeeze_dims() const {
6744 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SQUEEZE_DIMS);
6745 }
6746 bool Verify(flatbuffers::Verifier &verifier) const {
6747 return VerifyTableStart(verifier) &&
6748 VerifyOffset(verifier, VT_SQUEEZE_DIMS) &&
6749 verifier.VerifyVector(squeeze_dims()) &&
6750 verifier.EndTable();
6751 }
6752 SqueezeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6753 void UnPackTo(SqueezeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6754 static flatbuffers::Offset<SqueezeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6755};
6756
6757struct SqueezeOptionsBuilder {
6758 flatbuffers::FlatBufferBuilder &fbb_;
6759 flatbuffers::uoffset_t start_;
6760 void add_squeeze_dims(flatbuffers::Offset<flatbuffers::Vector<int32_t>> squeeze_dims) {
6761 fbb_.AddOffset(SqueezeOptions::VT_SQUEEZE_DIMS, squeeze_dims);
6762 }
6763 explicit SqueezeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6764 : fbb_(_fbb) {
6765 start_ = fbb_.StartTable();
6766 }
6767 SqueezeOptionsBuilder &operator=(const SqueezeOptionsBuilder &);
6768 flatbuffers::Offset<SqueezeOptions> Finish() {
6769 const auto end = fbb_.EndTable(start_);
6770 auto o = flatbuffers::Offset<SqueezeOptions>(end);
6771 return o;
6772 }
6773};
6774
6775inline flatbuffers::Offset<SqueezeOptions> CreateSqueezeOptions(
6776 flatbuffers::FlatBufferBuilder &_fbb,
6777 flatbuffers::Offset<flatbuffers::Vector<int32_t>> squeeze_dims = 0) {
6778 SqueezeOptionsBuilder builder_(_fbb);
6779 builder_.add_squeeze_dims(squeeze_dims);
6780 return builder_.Finish();
6781}
6782
6783inline flatbuffers::Offset<SqueezeOptions> CreateSqueezeOptionsDirect(
6784 flatbuffers::FlatBufferBuilder &_fbb,
6785 const std::vector<int32_t> *squeeze_dims = nullptr) {
6786 auto squeeze_dims__ = squeeze_dims ? _fbb.CreateVector<int32_t>(*squeeze_dims) : 0;
6787 return tflite::CreateSqueezeOptions(
6788 _fbb,
6789 squeeze_dims__);
6790}
6791
6792flatbuffers::Offset<SqueezeOptions> CreateSqueezeOptions(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6793
6794struct SplitOptionsT : public flatbuffers::NativeTable {
6795 typedef SplitOptions TableType;
6796 int32_t num_splits;
6797 SplitOptionsT()
6798 : num_splits(0) {
6799 }
6800};
6801
6802struct SplitOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6803 typedef SplitOptionsT NativeTableType;
6804 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6805 VT_NUM_SPLITS = 4
6806 };
6807 int32_t num_splits() const {
6808 return GetField<int32_t>(VT_NUM_SPLITS, 0);
6809 }
6810 bool Verify(flatbuffers::Verifier &verifier) const {
6811 return VerifyTableStart(verifier) &&
6812 VerifyField<int32_t>(verifier, VT_NUM_SPLITS) &&
6813 verifier.EndTable();
6814 }
6815 SplitOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6816 void UnPackTo(SplitOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6817 static flatbuffers::Offset<SplitOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6818};
6819
6820struct SplitOptionsBuilder {
6821 flatbuffers::FlatBufferBuilder &fbb_;
6822 flatbuffers::uoffset_t start_;
6823 void add_num_splits(int32_t num_splits) {
6824 fbb_.AddElement<int32_t>(SplitOptions::VT_NUM_SPLITS, num_splits, 0);
6825 }
6826 explicit SplitOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6827 : fbb_(_fbb) {
6828 start_ = fbb_.StartTable();
6829 }
6830 SplitOptionsBuilder &operator=(const SplitOptionsBuilder &);
6831 flatbuffers::Offset<SplitOptions> Finish() {
6832 const auto end = fbb_.EndTable(start_);
6833 auto o = flatbuffers::Offset<SplitOptions>(end);
6834 return o;
6835 }
6836};
6837
6838inline flatbuffers::Offset<SplitOptions> CreateSplitOptions(
6839 flatbuffers::FlatBufferBuilder &_fbb,
6840 int32_t num_splits = 0) {
6841 SplitOptionsBuilder builder_(_fbb);
6842 builder_.add_num_splits(num_splits);
6843 return builder_.Finish();
6844}
6845
6846flatbuffers::Offset<SplitOptions> CreateSplitOptions(flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6847
6848struct SplitVOptionsT : public flatbuffers::NativeTable {
6849 typedef SplitVOptions TableType;
6850 int32_t num_splits;
6851 SplitVOptionsT()
6852 : num_splits(0) {
6853 }
6854};
6855
6856struct SplitVOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6857 typedef SplitVOptionsT NativeTableType;
6858 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6859 VT_NUM_SPLITS = 4
6860 };
6861 int32_t num_splits() const {
6862 return GetField<int32_t>(VT_NUM_SPLITS, 0);
6863 }
6864 bool Verify(flatbuffers::Verifier &verifier) const {
6865 return VerifyTableStart(verifier) &&
6866 VerifyField<int32_t>(verifier, VT_NUM_SPLITS) &&
6867 verifier.EndTable();
6868 }
6869 SplitVOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6870 void UnPackTo(SplitVOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6871 static flatbuffers::Offset<SplitVOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6872};
6873
6874struct SplitVOptionsBuilder {
6875 flatbuffers::FlatBufferBuilder &fbb_;
6876 flatbuffers::uoffset_t start_;
6877 void add_num_splits(int32_t num_splits) {
6878 fbb_.AddElement<int32_t>(SplitVOptions::VT_NUM_SPLITS, num_splits, 0);
6879 }
6880 explicit SplitVOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6881 : fbb_(_fbb) {
6882 start_ = fbb_.StartTable();
6883 }
6884 SplitVOptionsBuilder &operator=(const SplitVOptionsBuilder &);
6885 flatbuffers::Offset<SplitVOptions> Finish() {
6886 const auto end = fbb_.EndTable(start_);
6887 auto o = flatbuffers::Offset<SplitVOptions>(end);
6888 return o;
6889 }
6890};
6891
6892inline flatbuffers::Offset<SplitVOptions> CreateSplitVOptions(
6893 flatbuffers::FlatBufferBuilder &_fbb,
6894 int32_t num_splits = 0) {
6895 SplitVOptionsBuilder builder_(_fbb);
6896 builder_.add_num_splits(num_splits);
6897 return builder_.Finish();
6898}
6899
6900flatbuffers::Offset<SplitVOptions> CreateSplitVOptions(flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6901
6902struct StridedSliceOptionsT : public flatbuffers::NativeTable {
6903 typedef StridedSliceOptions TableType;
6904 int32_t begin_mask;
6905 int32_t end_mask;
6906 int32_t ellipsis_mask;
6907 int32_t new_axis_mask;
6908 int32_t shrink_axis_mask;
6909 StridedSliceOptionsT()
6910 : begin_mask(0),
6911 end_mask(0),
6912 ellipsis_mask(0),
6913 new_axis_mask(0),
6914 shrink_axis_mask(0) {
6915 }
6916};
6917
6918struct StridedSliceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6919 typedef StridedSliceOptionsT NativeTableType;
6920 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6921 VT_BEGIN_MASK = 4,
6922 VT_END_MASK = 6,
6923 VT_ELLIPSIS_MASK = 8,
6924 VT_NEW_AXIS_MASK = 10,
6925 VT_SHRINK_AXIS_MASK = 12
6926 };
6927 int32_t begin_mask() const {
6928 return GetField<int32_t>(VT_BEGIN_MASK, 0);
6929 }
6930 int32_t end_mask() const {
6931 return GetField<int32_t>(VT_END_MASK, 0);
6932 }
6933 int32_t ellipsis_mask() const {
6934 return GetField<int32_t>(VT_ELLIPSIS_MASK, 0);
6935 }
6936 int32_t new_axis_mask() const {
6937 return GetField<int32_t>(VT_NEW_AXIS_MASK, 0);
6938 }
6939 int32_t shrink_axis_mask() const {
6940 return GetField<int32_t>(VT_SHRINK_AXIS_MASK, 0);
6941 }
6942 bool Verify(flatbuffers::Verifier &verifier) const {
6943 return VerifyTableStart(verifier) &&
6944 VerifyField<int32_t>(verifier, VT_BEGIN_MASK) &&
6945 VerifyField<int32_t>(verifier, VT_END_MASK) &&
6946 VerifyField<int32_t>(verifier, VT_ELLIPSIS_MASK) &&
6947 VerifyField<int32_t>(verifier, VT_NEW_AXIS_MASK) &&
6948 VerifyField<int32_t>(verifier, VT_SHRINK_AXIS_MASK) &&
6949 verifier.EndTable();
6950 }
6951 StridedSliceOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6952 void UnPackTo(StridedSliceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6953 static flatbuffers::Offset<StridedSliceOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6954};
6955
6956struct StridedSliceOptionsBuilder {
6957 flatbuffers::FlatBufferBuilder &fbb_;
6958 flatbuffers::uoffset_t start_;
6959 void add_begin_mask(int32_t begin_mask) {
6960 fbb_.AddElement<int32_t>(StridedSliceOptions::VT_BEGIN_MASK, begin_mask, 0);
6961 }
6962 void add_end_mask(int32_t end_mask) {
6963 fbb_.AddElement<int32_t>(StridedSliceOptions::VT_END_MASK, end_mask, 0);
6964 }
6965 void add_ellipsis_mask(int32_t ellipsis_mask) {
6966 fbb_.AddElement<int32_t>(StridedSliceOptions::VT_ELLIPSIS_MASK, ellipsis_mask, 0);
6967 }
6968 void add_new_axis_mask(int32_t new_axis_mask) {
6969 fbb_.AddElement<int32_t>(StridedSliceOptions::VT_NEW_AXIS_MASK, new_axis_mask, 0);
6970 }
6971 void add_shrink_axis_mask(int32_t shrink_axis_mask) {
6972 fbb_.AddElement<int32_t>(StridedSliceOptions::VT_SHRINK_AXIS_MASK, shrink_axis_mask, 0);
6973 }
6974 explicit StridedSliceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6975 : fbb_(_fbb) {
6976 start_ = fbb_.StartTable();
6977 }
6978 StridedSliceOptionsBuilder &operator=(const StridedSliceOptionsBuilder &);
6979 flatbuffers::Offset<StridedSliceOptions> Finish() {
6980 const auto end = fbb_.EndTable(start_);
6981 auto o = flatbuffers::Offset<StridedSliceOptions>(end);
6982 return o;
6983 }
6984};
6985
6986inline flatbuffers::Offset<StridedSliceOptions> CreateStridedSliceOptions(
6987 flatbuffers::FlatBufferBuilder &_fbb,
6988 int32_t begin_mask = 0,
6989 int32_t end_mask = 0,
6990 int32_t ellipsis_mask = 0,
6991 int32_t new_axis_mask = 0,
6992 int32_t shrink_axis_mask = 0) {
6993 StridedSliceOptionsBuilder builder_(_fbb);
6994 builder_.add_shrink_axis_mask(shrink_axis_mask);
6995 builder_.add_new_axis_mask(new_axis_mask);
6996 builder_.add_ellipsis_mask(ellipsis_mask);
6997 builder_.add_end_mask(end_mask);
6998 builder_.add_begin_mask(begin_mask);
6999 return builder_.Finish();
7000}
7001
7002flatbuffers::Offset<StridedSliceOptions> CreateStridedSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7003
7004struct LogSoftmaxOptionsT : public flatbuffers::NativeTable {
7005 typedef LogSoftmaxOptions TableType;
7006 LogSoftmaxOptionsT() {
7007 }
7008};
7009
7010struct LogSoftmaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7011 typedef LogSoftmaxOptionsT NativeTableType;
7012 bool Verify(flatbuffers::Verifier &verifier) const {
7013 return VerifyTableStart(verifier) &&
7014 verifier.EndTable();
7015 }
7016 LogSoftmaxOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7017 void UnPackTo(LogSoftmaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7018 static flatbuffers::Offset<LogSoftmaxOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7019};
7020
7021struct LogSoftmaxOptionsBuilder {
7022 flatbuffers::FlatBufferBuilder &fbb_;
7023 flatbuffers::uoffset_t start_;
7024 explicit LogSoftmaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7025 : fbb_(_fbb) {
7026 start_ = fbb_.StartTable();
7027 }
7028 LogSoftmaxOptionsBuilder &operator=(const LogSoftmaxOptionsBuilder &);
7029 flatbuffers::Offset<LogSoftmaxOptions> Finish() {
7030 const auto end = fbb_.EndTable(start_);
7031 auto o = flatbuffers::Offset<LogSoftmaxOptions>(end);
7032 return o;
7033 }
7034};
7035
7036inline flatbuffers::Offset<LogSoftmaxOptions> CreateLogSoftmaxOptions(
7037 flatbuffers::FlatBufferBuilder &_fbb) {
7038 LogSoftmaxOptionsBuilder builder_(_fbb);
7039 return builder_.Finish();
7040}
7041
7042flatbuffers::Offset<LogSoftmaxOptions> CreateLogSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7043
7044struct CastOptionsT : public flatbuffers::NativeTable {
7045 typedef CastOptions TableType;
7046 tflite::TensorType in_data_type;
7047 tflite::TensorType out_data_type;
7048 CastOptionsT()
7049 : in_data_type(tflite::TensorType_FLOAT32),
7050 out_data_type(tflite::TensorType_FLOAT32) {
7051 }
7052};
7053
7054struct CastOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7055 typedef CastOptionsT NativeTableType;
7056 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7057 VT_IN_DATA_TYPE = 4,
7058 VT_OUT_DATA_TYPE = 6
7059 };
7060 tflite::TensorType in_data_type() const {
7061 return static_cast<tflite::TensorType>(GetField<int8_t>(VT_IN_DATA_TYPE, 0));
7062 }
7063 tflite::TensorType out_data_type() const {
7064 return static_cast<tflite::TensorType>(GetField<int8_t>(VT_OUT_DATA_TYPE, 0));
7065 }
7066 bool Verify(flatbuffers::Verifier &verifier) const {
7067 return VerifyTableStart(verifier) &&
7068 VerifyField<int8_t>(verifier, VT_IN_DATA_TYPE) &&
7069 VerifyField<int8_t>(verifier, VT_OUT_DATA_TYPE) &&
7070 verifier.EndTable();
7071 }
7072 CastOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7073 void UnPackTo(CastOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7074 static flatbuffers::Offset<CastOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7075};
7076
7077struct CastOptionsBuilder {
7078 flatbuffers::FlatBufferBuilder &fbb_;
7079 flatbuffers::uoffset_t start_;
7080 void add_in_data_type(tflite::TensorType in_data_type) {
7081 fbb_.AddElement<int8_t>(CastOptions::VT_IN_DATA_TYPE, static_cast<int8_t>(in_data_type), 0);
7082 }
7083 void add_out_data_type(tflite::TensorType out_data_type) {
7084 fbb_.AddElement<int8_t>(CastOptions::VT_OUT_DATA_TYPE, static_cast<int8_t>(out_data_type), 0);
7085 }
7086 explicit CastOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7087 : fbb_(_fbb) {
7088 start_ = fbb_.StartTable();
7089 }
7090 CastOptionsBuilder &operator=(const CastOptionsBuilder &);
7091 flatbuffers::Offset<CastOptions> Finish() {
7092 const auto end = fbb_.EndTable(start_);
7093 auto o = flatbuffers::Offset<CastOptions>(end);
7094 return o;
7095 }
7096};
7097
7098inline flatbuffers::Offset<CastOptions> CreateCastOptions(
7099 flatbuffers::FlatBufferBuilder &_fbb,
7100 tflite::TensorType in_data_type = tflite::TensorType_FLOAT32,
7101 tflite::TensorType out_data_type = tflite::TensorType_FLOAT32) {
7102 CastOptionsBuilder builder_(_fbb);
7103 builder_.add_out_data_type(out_data_type);
7104 builder_.add_in_data_type(in_data_type);
7105 return builder_.Finish();
7106}
7107
7108flatbuffers::Offset<CastOptions> CreateCastOptions(flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7109
7110struct DequantizeOptionsT : public flatbuffers::NativeTable {
7111 typedef DequantizeOptions TableType;
7112 DequantizeOptionsT() {
7113 }
7114};
7115
7116struct DequantizeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7117 typedef DequantizeOptionsT NativeTableType;
7118 bool Verify(flatbuffers::Verifier &verifier) const {
7119 return VerifyTableStart(verifier) &&
7120 verifier.EndTable();
7121 }
7122 DequantizeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7123 void UnPackTo(DequantizeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7124 static flatbuffers::Offset<DequantizeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7125};
7126
7127struct DequantizeOptionsBuilder {
7128 flatbuffers::FlatBufferBuilder &fbb_;
7129 flatbuffers::uoffset_t start_;
7130 explicit DequantizeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7131 : fbb_(_fbb) {
7132 start_ = fbb_.StartTable();
7133 }
7134 DequantizeOptionsBuilder &operator=(const DequantizeOptionsBuilder &);
7135 flatbuffers::Offset<DequantizeOptions> Finish() {
7136 const auto end = fbb_.EndTable(start_);
7137 auto o = flatbuffers::Offset<DequantizeOptions>(end);
7138 return o;
7139 }
7140};
7141
7142inline flatbuffers::Offset<DequantizeOptions> CreateDequantizeOptions(
7143 flatbuffers::FlatBufferBuilder &_fbb) {
7144 DequantizeOptionsBuilder builder_(_fbb);
7145 return builder_.Finish();
7146}
7147
7148flatbuffers::Offset<DequantizeOptions> CreateDequantizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7149
7150struct MaximumMinimumOptionsT : public flatbuffers::NativeTable {
7151 typedef MaximumMinimumOptions TableType;
7152 MaximumMinimumOptionsT() {
7153 }
7154};
7155
7156struct MaximumMinimumOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7157 typedef MaximumMinimumOptionsT NativeTableType;
7158 bool Verify(flatbuffers::Verifier &verifier) const {
7159 return VerifyTableStart(verifier) &&
7160 verifier.EndTable();
7161 }
7162 MaximumMinimumOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7163 void UnPackTo(MaximumMinimumOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7164 static flatbuffers::Offset<MaximumMinimumOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7165};
7166
7167struct MaximumMinimumOptionsBuilder {
7168 flatbuffers::FlatBufferBuilder &fbb_;
7169 flatbuffers::uoffset_t start_;
7170 explicit MaximumMinimumOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7171 : fbb_(_fbb) {
7172 start_ = fbb_.StartTable();
7173 }
7174 MaximumMinimumOptionsBuilder &operator=(const MaximumMinimumOptionsBuilder &);
7175 flatbuffers::Offset<MaximumMinimumOptions> Finish() {
7176 const auto end = fbb_.EndTable(start_);
7177 auto o = flatbuffers::Offset<MaximumMinimumOptions>(end);
7178 return o;
7179 }
7180};
7181
7182inline flatbuffers::Offset<MaximumMinimumOptions> CreateMaximumMinimumOptions(
7183 flatbuffers::FlatBufferBuilder &_fbb) {
7184 MaximumMinimumOptionsBuilder builder_(_fbb);
7185 return builder_.Finish();
7186}
7187
7188flatbuffers::Offset<MaximumMinimumOptions> CreateMaximumMinimumOptions(flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7189
7190struct TileOptionsT : public flatbuffers::NativeTable {
7191 typedef TileOptions TableType;
7192 TileOptionsT() {
7193 }
7194};
7195
7196struct TileOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7197 typedef TileOptionsT NativeTableType;
7198 bool Verify(flatbuffers::Verifier &verifier) const {
7199 return VerifyTableStart(verifier) &&
7200 verifier.EndTable();
7201 }
7202 TileOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7203 void UnPackTo(TileOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7204 static flatbuffers::Offset<TileOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7205};
7206
7207struct TileOptionsBuilder {
7208 flatbuffers::FlatBufferBuilder &fbb_;
7209 flatbuffers::uoffset_t start_;
7210 explicit TileOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7211 : fbb_(_fbb) {
7212 start_ = fbb_.StartTable();
7213 }
7214 TileOptionsBuilder &operator=(const TileOptionsBuilder &);
7215 flatbuffers::Offset<TileOptions> Finish() {
7216 const auto end = fbb_.EndTable(start_);
7217 auto o = flatbuffers::Offset<TileOptions>(end);
7218 return o;
7219 }
7220};
7221
7222inline flatbuffers::Offset<TileOptions> CreateTileOptions(
7223 flatbuffers::FlatBufferBuilder &_fbb) {
7224 TileOptionsBuilder builder_(_fbb);
7225 return builder_.Finish();
7226}
7227
7228flatbuffers::Offset<TileOptions> CreateTileOptions(flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7229
7230struct ArgMaxOptionsT : public flatbuffers::NativeTable {
7231 typedef ArgMaxOptions TableType;
7232 tflite::TensorType output_type;
7233 ArgMaxOptionsT()
7234 : output_type(tflite::TensorType_FLOAT32) {
7235 }
7236};
7237
7238struct ArgMaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7239 typedef ArgMaxOptionsT NativeTableType;
7240 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7241 VT_OUTPUT_TYPE = 4
7242 };
7243 tflite::TensorType output_type() const {
7244 return static_cast<tflite::TensorType>(GetField<int8_t>(VT_OUTPUT_TYPE, 0));
7245 }
7246 bool Verify(flatbuffers::Verifier &verifier) const {
7247 return VerifyTableStart(verifier) &&
7248 VerifyField<int8_t>(verifier, VT_OUTPUT_TYPE) &&
7249 verifier.EndTable();
7250 }
7251 ArgMaxOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7252 void UnPackTo(ArgMaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7253 static flatbuffers::Offset<ArgMaxOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7254};
7255
7256struct ArgMaxOptionsBuilder {
7257 flatbuffers::FlatBufferBuilder &fbb_;
7258 flatbuffers::uoffset_t start_;
7259 void add_output_type(tflite::TensorType output_type) {
7260 fbb_.AddElement<int8_t>(ArgMaxOptions::VT_OUTPUT_TYPE, static_cast<int8_t>(output_type), 0);
7261 }
7262 explicit ArgMaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7263 : fbb_(_fbb) {
7264 start_ = fbb_.StartTable();
7265 }
7266 ArgMaxOptionsBuilder &operator=(const ArgMaxOptionsBuilder &);
7267 flatbuffers::Offset<ArgMaxOptions> Finish() {
7268 const auto end = fbb_.EndTable(start_);
7269 auto o = flatbuffers::Offset<ArgMaxOptions>(end);
7270 return o;
7271 }
7272};
7273
7274inline flatbuffers::Offset<ArgMaxOptions> CreateArgMaxOptions(
7275 flatbuffers::FlatBufferBuilder &_fbb,
7276 tflite::TensorType output_type = tflite::TensorType_FLOAT32) {
7277 ArgMaxOptionsBuilder builder_(_fbb);
7278 builder_.add_output_type(output_type);
7279 return builder_.Finish();
7280}
7281
7282flatbuffers::Offset<ArgMaxOptions> CreateArgMaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7283
7284struct ArgMinOptionsT : public flatbuffers::NativeTable {
7285 typedef ArgMinOptions TableType;
7286 tflite::TensorType output_type;
7287 ArgMinOptionsT()
7288 : output_type(tflite::TensorType_FLOAT32) {
7289 }
7290};
7291
7292struct ArgMinOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7293 typedef ArgMinOptionsT NativeTableType;
7294 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7295 VT_OUTPUT_TYPE = 4
7296 };
7297 tflite::TensorType output_type() const {
7298 return static_cast<tflite::TensorType>(GetField<int8_t>(VT_OUTPUT_TYPE, 0));
7299 }
7300 bool Verify(flatbuffers::Verifier &verifier) const {
7301 return VerifyTableStart(verifier) &&
7302 VerifyField<int8_t>(verifier, VT_OUTPUT_TYPE) &&
7303 verifier.EndTable();
7304 }
7305 ArgMinOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7306 void UnPackTo(ArgMinOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7307 static flatbuffers::Offset<ArgMinOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7308};
7309
7310struct ArgMinOptionsBuilder {
7311 flatbuffers::FlatBufferBuilder &fbb_;
7312 flatbuffers::uoffset_t start_;
7313 void add_output_type(tflite::TensorType output_type) {
7314 fbb_.AddElement<int8_t>(ArgMinOptions::VT_OUTPUT_TYPE, static_cast<int8_t>(output_type), 0);
7315 }
7316 explicit ArgMinOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7317 : fbb_(_fbb) {
7318 start_ = fbb_.StartTable();
7319 }
7320 ArgMinOptionsBuilder &operator=(const ArgMinOptionsBuilder &);
7321 flatbuffers::Offset<ArgMinOptions> Finish() {
7322 const auto end = fbb_.EndTable(start_);
7323 auto o = flatbuffers::Offset<ArgMinOptions>(end);
7324 return o;
7325 }
7326};
7327
7328inline flatbuffers::Offset<ArgMinOptions> CreateArgMinOptions(
7329 flatbuffers::FlatBufferBuilder &_fbb,
7330 tflite::TensorType output_type = tflite::TensorType_FLOAT32) {
7331 ArgMinOptionsBuilder builder_(_fbb);
7332 builder_.add_output_type(output_type);
7333 return builder_.Finish();
7334}
7335
7336flatbuffers::Offset<ArgMinOptions> CreateArgMinOptions(flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7337
7338struct GreaterOptionsT : public flatbuffers::NativeTable {
7339 typedef GreaterOptions TableType;
7340 GreaterOptionsT() {
7341 }
7342};
7343
7344struct GreaterOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7345 typedef GreaterOptionsT NativeTableType;
7346 bool Verify(flatbuffers::Verifier &verifier) const {
7347 return VerifyTableStart(verifier) &&
7348 verifier.EndTable();
7349 }
7350 GreaterOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7351 void UnPackTo(GreaterOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7352 static flatbuffers::Offset<GreaterOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7353};
7354
7355struct GreaterOptionsBuilder {
7356 flatbuffers::FlatBufferBuilder &fbb_;
7357 flatbuffers::uoffset_t start_;
7358 explicit GreaterOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7359 : fbb_(_fbb) {
7360 start_ = fbb_.StartTable();
7361 }
7362 GreaterOptionsBuilder &operator=(const GreaterOptionsBuilder &);
7363 flatbuffers::Offset<GreaterOptions> Finish() {
7364 const auto end = fbb_.EndTable(start_);
7365 auto o = flatbuffers::Offset<GreaterOptions>(end);
7366 return o;
7367 }
7368};
7369
7370inline flatbuffers::Offset<GreaterOptions> CreateGreaterOptions(
7371 flatbuffers::FlatBufferBuilder &_fbb) {
7372 GreaterOptionsBuilder builder_(_fbb);
7373 return builder_.Finish();
7374}
7375
7376flatbuffers::Offset<GreaterOptions> CreateGreaterOptions(flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7377
7378struct GreaterEqualOptionsT : public flatbuffers::NativeTable {
7379 typedef GreaterEqualOptions TableType;
7380 GreaterEqualOptionsT() {
7381 }
7382};
7383
7384struct GreaterEqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7385 typedef GreaterEqualOptionsT NativeTableType;
7386 bool Verify(flatbuffers::Verifier &verifier) const {
7387 return VerifyTableStart(verifier) &&
7388 verifier.EndTable();
7389 }
7390 GreaterEqualOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7391 void UnPackTo(GreaterEqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7392 static flatbuffers::Offset<GreaterEqualOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7393};
7394
7395struct GreaterEqualOptionsBuilder {
7396 flatbuffers::FlatBufferBuilder &fbb_;
7397 flatbuffers::uoffset_t start_;
7398 explicit GreaterEqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7399 : fbb_(_fbb) {
7400 start_ = fbb_.StartTable();
7401 }
7402 GreaterEqualOptionsBuilder &operator=(const GreaterEqualOptionsBuilder &);
7403 flatbuffers::Offset<GreaterEqualOptions> Finish() {
7404 const auto end = fbb_.EndTable(start_);
7405 auto o = flatbuffers::Offset<GreaterEqualOptions>(end);
7406 return o;
7407 }
7408};
7409
7410inline flatbuffers::Offset<GreaterEqualOptions> CreateGreaterEqualOptions(
7411 flatbuffers::FlatBufferBuilder &_fbb) {
7412 GreaterEqualOptionsBuilder builder_(_fbb);
7413 return builder_.Finish();
7414}
7415
7416flatbuffers::Offset<GreaterEqualOptions> CreateGreaterEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7417
7418struct LessOptionsT : public flatbuffers::NativeTable {
7419 typedef LessOptions TableType;
7420 LessOptionsT() {
7421 }
7422};
7423
7424struct LessOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7425 typedef LessOptionsT NativeTableType;
7426 bool Verify(flatbuffers::Verifier &verifier) const {
7427 return VerifyTableStart(verifier) &&
7428 verifier.EndTable();
7429 }
7430 LessOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7431 void UnPackTo(LessOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7432 static flatbuffers::Offset<LessOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7433};
7434
7435struct LessOptionsBuilder {
7436 flatbuffers::FlatBufferBuilder &fbb_;
7437 flatbuffers::uoffset_t start_;
7438 explicit LessOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7439 : fbb_(_fbb) {
7440 start_ = fbb_.StartTable();
7441 }
7442 LessOptionsBuilder &operator=(const LessOptionsBuilder &);
7443 flatbuffers::Offset<LessOptions> Finish() {
7444 const auto end = fbb_.EndTable(start_);
7445 auto o = flatbuffers::Offset<LessOptions>(end);
7446 return o;
7447 }
7448};
7449
7450inline flatbuffers::Offset<LessOptions> CreateLessOptions(
7451 flatbuffers::FlatBufferBuilder &_fbb) {
7452 LessOptionsBuilder builder_(_fbb);
7453 return builder_.Finish();
7454}
7455
7456flatbuffers::Offset<LessOptions> CreateLessOptions(flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7457
7458struct LessEqualOptionsT : public flatbuffers::NativeTable {
7459 typedef LessEqualOptions TableType;
7460 LessEqualOptionsT() {
7461 }
7462};
7463
7464struct LessEqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7465 typedef LessEqualOptionsT NativeTableType;
7466 bool Verify(flatbuffers::Verifier &verifier) const {
7467 return VerifyTableStart(verifier) &&
7468 verifier.EndTable();
7469 }
7470 LessEqualOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7471 void UnPackTo(LessEqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7472 static flatbuffers::Offset<LessEqualOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7473};
7474
7475struct LessEqualOptionsBuilder {
7476 flatbuffers::FlatBufferBuilder &fbb_;
7477 flatbuffers::uoffset_t start_;
7478 explicit LessEqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7479 : fbb_(_fbb) {
7480 start_ = fbb_.StartTable();
7481 }
7482 LessEqualOptionsBuilder &operator=(const LessEqualOptionsBuilder &);
7483 flatbuffers::Offset<LessEqualOptions> Finish() {
7484 const auto end = fbb_.EndTable(start_);
7485 auto o = flatbuffers::Offset<LessEqualOptions>(end);
7486 return o;
7487 }
7488};
7489
7490inline flatbuffers::Offset<LessEqualOptions> CreateLessEqualOptions(
7491 flatbuffers::FlatBufferBuilder &_fbb) {
7492 LessEqualOptionsBuilder builder_(_fbb);
7493 return builder_.Finish();
7494}
7495
7496flatbuffers::Offset<LessEqualOptions> CreateLessEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7497
7498struct NegOptionsT : public flatbuffers::NativeTable {
7499 typedef NegOptions TableType;
7500 NegOptionsT() {
7501 }
7502};
7503
7504struct NegOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7505 typedef NegOptionsT NativeTableType;
7506 bool Verify(flatbuffers::Verifier &verifier) const {
7507 return VerifyTableStart(verifier) &&
7508 verifier.EndTable();
7509 }
7510 NegOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7511 void UnPackTo(NegOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7512 static flatbuffers::Offset<NegOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7513};
7514
7515struct NegOptionsBuilder {
7516 flatbuffers::FlatBufferBuilder &fbb_;
7517 flatbuffers::uoffset_t start_;
7518 explicit NegOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7519 : fbb_(_fbb) {
7520 start_ = fbb_.StartTable();
7521 }
7522 NegOptionsBuilder &operator=(const NegOptionsBuilder &);
7523 flatbuffers::Offset<NegOptions> Finish() {
7524 const auto end = fbb_.EndTable(start_);
7525 auto o = flatbuffers::Offset<NegOptions>(end);
7526 return o;
7527 }
7528};
7529
7530inline flatbuffers::Offset<NegOptions> CreateNegOptions(
7531 flatbuffers::FlatBufferBuilder &_fbb) {
7532 NegOptionsBuilder builder_(_fbb);
7533 return builder_.Finish();
7534}
7535
7536flatbuffers::Offset<NegOptions> CreateNegOptions(flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7537
7538struct SelectOptionsT : public flatbuffers::NativeTable {
7539 typedef SelectOptions TableType;
7540 SelectOptionsT() {
7541 }
7542};
7543
7544struct SelectOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7545 typedef SelectOptionsT NativeTableType;
7546 bool Verify(flatbuffers::Verifier &verifier) const {
7547 return VerifyTableStart(verifier) &&
7548 verifier.EndTable();
7549 }
7550 SelectOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7551 void UnPackTo(SelectOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7552 static flatbuffers::Offset<SelectOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7553};
7554
7555struct SelectOptionsBuilder {
7556 flatbuffers::FlatBufferBuilder &fbb_;
7557 flatbuffers::uoffset_t start_;
7558 explicit SelectOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7559 : fbb_(_fbb) {
7560 start_ = fbb_.StartTable();
7561 }
7562 SelectOptionsBuilder &operator=(const SelectOptionsBuilder &);
7563 flatbuffers::Offset<SelectOptions> Finish() {
7564 const auto end = fbb_.EndTable(start_);
7565 auto o = flatbuffers::Offset<SelectOptions>(end);
7566 return o;
7567 }
7568};
7569
7570inline flatbuffers::Offset<SelectOptions> CreateSelectOptions(
7571 flatbuffers::FlatBufferBuilder &_fbb) {
7572 SelectOptionsBuilder builder_(_fbb);
7573 return builder_.Finish();
7574}
7575
7576flatbuffers::Offset<SelectOptions> CreateSelectOptions(flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7577
7578struct SliceOptionsT : public flatbuffers::NativeTable {
7579 typedef SliceOptions TableType;
7580 SliceOptionsT() {
7581 }
7582};
7583
7584struct SliceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7585 typedef SliceOptionsT NativeTableType;
7586 bool Verify(flatbuffers::Verifier &verifier) const {
7587 return VerifyTableStart(verifier) &&
7588 verifier.EndTable();
7589 }
7590 SliceOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7591 void UnPackTo(SliceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7592 static flatbuffers::Offset<SliceOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7593};
7594
7595struct SliceOptionsBuilder {
7596 flatbuffers::FlatBufferBuilder &fbb_;
7597 flatbuffers::uoffset_t start_;
7598 explicit SliceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7599 : fbb_(_fbb) {
7600 start_ = fbb_.StartTable();
7601 }
7602 SliceOptionsBuilder &operator=(const SliceOptionsBuilder &);
7603 flatbuffers::Offset<SliceOptions> Finish() {
7604 const auto end = fbb_.EndTable(start_);
7605 auto o = flatbuffers::Offset<SliceOptions>(end);
7606 return o;
7607 }
7608};
7609
7610inline flatbuffers::Offset<SliceOptions> CreateSliceOptions(
7611 flatbuffers::FlatBufferBuilder &_fbb) {
7612 SliceOptionsBuilder builder_(_fbb);
7613 return builder_.Finish();
7614}
7615
7616flatbuffers::Offset<SliceOptions> CreateSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7617
7618struct TransposeConvOptionsT : public flatbuffers::NativeTable {
7619 typedef TransposeConvOptions TableType;
7620 tflite::Padding padding;
7621 int32_t stride_w;
7622 int32_t stride_h;
7623 TransposeConvOptionsT()
7624 : padding(tflite::Padding_SAME),
7625 stride_w(0),
7626 stride_h(0) {
7627 }
7628};
7629
7630struct TransposeConvOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7631 typedef TransposeConvOptionsT NativeTableType;
7632 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7633 VT_PADDING = 4,
7634 VT_STRIDE_W = 6,
7635 VT_STRIDE_H = 8
7636 };
7637 tflite::Padding padding() const {
7638 return static_cast<tflite::Padding>(GetField<int8_t>(VT_PADDING, 0));
7639 }
7640 int32_t stride_w() const {
7641 return GetField<int32_t>(VT_STRIDE_W, 0);
7642 }
7643 int32_t stride_h() const {
7644 return GetField<int32_t>(VT_STRIDE_H, 0);
7645 }
7646 bool Verify(flatbuffers::Verifier &verifier) const {
7647 return VerifyTableStart(verifier) &&
7648 VerifyField<int8_t>(verifier, VT_PADDING) &&
7649 VerifyField<int32_t>(verifier, VT_STRIDE_W) &&
7650 VerifyField<int32_t>(verifier, VT_STRIDE_H) &&
7651 verifier.EndTable();
7652 }
7653 TransposeConvOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7654 void UnPackTo(TransposeConvOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7655 static flatbuffers::Offset<TransposeConvOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7656};
7657
7658struct TransposeConvOptionsBuilder {
7659 flatbuffers::FlatBufferBuilder &fbb_;
7660 flatbuffers::uoffset_t start_;
7661 void add_padding(tflite::Padding padding) {
7662 fbb_.AddElement<int8_t>(TransposeConvOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
7663 }
7664 void add_stride_w(int32_t stride_w) {
7665 fbb_.AddElement<int32_t>(TransposeConvOptions::VT_STRIDE_W, stride_w, 0);
7666 }
7667 void add_stride_h(int32_t stride_h) {
7668 fbb_.AddElement<int32_t>(TransposeConvOptions::VT_STRIDE_H, stride_h, 0);
7669 }
7670 explicit TransposeConvOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7671 : fbb_(_fbb) {
7672 start_ = fbb_.StartTable();
7673 }
7674 TransposeConvOptionsBuilder &operator=(const TransposeConvOptionsBuilder &);
7675 flatbuffers::Offset<TransposeConvOptions> Finish() {
7676 const auto end = fbb_.EndTable(start_);
7677 auto o = flatbuffers::Offset<TransposeConvOptions>(end);
7678 return o;
7679 }
7680};
7681
7682inline flatbuffers::Offset<TransposeConvOptions> CreateTransposeConvOptions(
7683 flatbuffers::FlatBufferBuilder &_fbb,
7684 tflite::Padding padding = tflite::Padding_SAME,
7685 int32_t stride_w = 0,
7686 int32_t stride_h = 0) {
7687 TransposeConvOptionsBuilder builder_(_fbb);
7688 builder_.add_stride_h(stride_h);
7689 builder_.add_stride_w(stride_w);
7690 builder_.add_padding(padding);
7691 return builder_.Finish();
7692}
7693
7694flatbuffers::Offset<TransposeConvOptions> CreateTransposeConvOptions(flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7695
7696struct ExpandDimsOptionsT : public flatbuffers::NativeTable {
7697 typedef ExpandDimsOptions TableType;
7698 ExpandDimsOptionsT() {
7699 }
7700};
7701
7702struct ExpandDimsOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7703 typedef ExpandDimsOptionsT NativeTableType;
7704 bool Verify(flatbuffers::Verifier &verifier) const {
7705 return VerifyTableStart(verifier) &&
7706 verifier.EndTable();
7707 }
7708 ExpandDimsOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7709 void UnPackTo(ExpandDimsOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7710 static flatbuffers::Offset<ExpandDimsOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7711};
7712
7713struct ExpandDimsOptionsBuilder {
7714 flatbuffers::FlatBufferBuilder &fbb_;
7715 flatbuffers::uoffset_t start_;
7716 explicit ExpandDimsOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7717 : fbb_(_fbb) {
7718 start_ = fbb_.StartTable();
7719 }
7720 ExpandDimsOptionsBuilder &operator=(const ExpandDimsOptionsBuilder &);
7721 flatbuffers::Offset<ExpandDimsOptions> Finish() {
7722 const auto end = fbb_.EndTable(start_);
7723 auto o = flatbuffers::Offset<ExpandDimsOptions>(end);
7724 return o;
7725 }
7726};
7727
7728inline flatbuffers::Offset<ExpandDimsOptions> CreateExpandDimsOptions(
7729 flatbuffers::FlatBufferBuilder &_fbb) {
7730 ExpandDimsOptionsBuilder builder_(_fbb);
7731 return builder_.Finish();
7732}
7733
7734flatbuffers::Offset<ExpandDimsOptions> CreateExpandDimsOptions(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7735
7736struct SparseToDenseOptionsT : public flatbuffers::NativeTable {
7737 typedef SparseToDenseOptions TableType;
7738 bool validate_indices;
7739 SparseToDenseOptionsT()
7740 : validate_indices(false) {
7741 }
7742};
7743
7744struct SparseToDenseOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7745 typedef SparseToDenseOptionsT NativeTableType;
7746 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7747 VT_VALIDATE_INDICES = 4
7748 };
7749 bool validate_indices() const {
7750 return GetField<uint8_t>(VT_VALIDATE_INDICES, 0) != 0;
7751 }
7752 bool Verify(flatbuffers::Verifier &verifier) const {
7753 return VerifyTableStart(verifier) &&
7754 VerifyField<uint8_t>(verifier, VT_VALIDATE_INDICES) &&
7755 verifier.EndTable();
7756 }
7757 SparseToDenseOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7758 void UnPackTo(SparseToDenseOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7759 static flatbuffers::Offset<SparseToDenseOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7760};
7761
7762struct SparseToDenseOptionsBuilder {
7763 flatbuffers::FlatBufferBuilder &fbb_;
7764 flatbuffers::uoffset_t start_;
7765 void add_validate_indices(bool validate_indices) {
7766 fbb_.AddElement<uint8_t>(SparseToDenseOptions::VT_VALIDATE_INDICES, static_cast<uint8_t>(validate_indices), 0);
7767 }
7768 explicit SparseToDenseOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7769 : fbb_(_fbb) {
7770 start_ = fbb_.StartTable();
7771 }
7772 SparseToDenseOptionsBuilder &operator=(const SparseToDenseOptionsBuilder &);
7773 flatbuffers::Offset<SparseToDenseOptions> Finish() {
7774 const auto end = fbb_.EndTable(start_);
7775 auto o = flatbuffers::Offset<SparseToDenseOptions>(end);
7776 return o;
7777 }
7778};
7779
7780inline flatbuffers::Offset<SparseToDenseOptions> CreateSparseToDenseOptions(
7781 flatbuffers::FlatBufferBuilder &_fbb,
7782 bool validate_indices = false) {
7783 SparseToDenseOptionsBuilder builder_(_fbb);
7784 builder_.add_validate_indices(validate_indices);
7785 return builder_.Finish();
7786}
7787
7788flatbuffers::Offset<SparseToDenseOptions> CreateSparseToDenseOptions(flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7789
7790struct EqualOptionsT : public flatbuffers::NativeTable {
7791 typedef EqualOptions TableType;
7792 EqualOptionsT() {
7793 }
7794};
7795
7796struct EqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7797 typedef EqualOptionsT NativeTableType;
7798 bool Verify(flatbuffers::Verifier &verifier) const {
7799 return VerifyTableStart(verifier) &&
7800 verifier.EndTable();
7801 }
7802 EqualOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7803 void UnPackTo(EqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7804 static flatbuffers::Offset<EqualOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7805};
7806
7807struct EqualOptionsBuilder {
7808 flatbuffers::FlatBufferBuilder &fbb_;
7809 flatbuffers::uoffset_t start_;
7810 explicit EqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7811 : fbb_(_fbb) {
7812 start_ = fbb_.StartTable();
7813 }
7814 EqualOptionsBuilder &operator=(const EqualOptionsBuilder &);
7815 flatbuffers::Offset<EqualOptions> Finish() {
7816 const auto end = fbb_.EndTable(start_);
7817 auto o = flatbuffers::Offset<EqualOptions>(end);
7818 return o;
7819 }
7820};
7821
7822inline flatbuffers::Offset<EqualOptions> CreateEqualOptions(
7823 flatbuffers::FlatBufferBuilder &_fbb) {
7824 EqualOptionsBuilder builder_(_fbb);
7825 return builder_.Finish();
7826}
7827
7828flatbuffers::Offset<EqualOptions> CreateEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7829
7830struct NotEqualOptionsT : public flatbuffers::NativeTable {
7831 typedef NotEqualOptions TableType;
7832 NotEqualOptionsT() {
7833 }
7834};
7835
7836struct NotEqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7837 typedef NotEqualOptionsT NativeTableType;
7838 bool Verify(flatbuffers::Verifier &verifier) const {
7839 return VerifyTableStart(verifier) &&
7840 verifier.EndTable();
7841 }
7842 NotEqualOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7843 void UnPackTo(NotEqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7844 static flatbuffers::Offset<NotEqualOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7845};
7846
7847struct NotEqualOptionsBuilder {
7848 flatbuffers::FlatBufferBuilder &fbb_;
7849 flatbuffers::uoffset_t start_;
7850 explicit NotEqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7851 : fbb_(_fbb) {
7852 start_ = fbb_.StartTable();
7853 }
7854 NotEqualOptionsBuilder &operator=(const NotEqualOptionsBuilder &);
7855 flatbuffers::Offset<NotEqualOptions> Finish() {
7856 const auto end = fbb_.EndTable(start_);
7857 auto o = flatbuffers::Offset<NotEqualOptions>(end);
7858 return o;
7859 }
7860};
7861
7862inline flatbuffers::Offset<NotEqualOptions> CreateNotEqualOptions(
7863 flatbuffers::FlatBufferBuilder &_fbb) {
7864 NotEqualOptionsBuilder builder_(_fbb);
7865 return builder_.Finish();
7866}
7867
7868flatbuffers::Offset<NotEqualOptions> CreateNotEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7869
7870struct ShapeOptionsT : public flatbuffers::NativeTable {
7871 typedef ShapeOptions TableType;
7872 tflite::TensorType out_type;
7873 ShapeOptionsT()
7874 : out_type(tflite::TensorType_FLOAT32) {
7875 }
7876};
7877
7878struct ShapeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7879 typedef ShapeOptionsT NativeTableType;
7880 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7881 VT_OUT_TYPE = 4
7882 };
7883 tflite::TensorType out_type() const {
7884 return static_cast<tflite::TensorType>(GetField<int8_t>(VT_OUT_TYPE, 0));
7885 }
7886 bool Verify(flatbuffers::Verifier &verifier) const {
7887 return VerifyTableStart(verifier) &&
7888 VerifyField<int8_t>(verifier, VT_OUT_TYPE) &&
7889 verifier.EndTable();
7890 }
7891 ShapeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7892 void UnPackTo(ShapeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7893 static flatbuffers::Offset<ShapeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7894};
7895
7896struct ShapeOptionsBuilder {
7897 flatbuffers::FlatBufferBuilder &fbb_;
7898 flatbuffers::uoffset_t start_;
7899 void add_out_type(tflite::TensorType out_type) {
7900 fbb_.AddElement<int8_t>(ShapeOptions::VT_OUT_TYPE, static_cast<int8_t>(out_type), 0);
7901 }
7902 explicit ShapeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7903 : fbb_(_fbb) {
7904 start_ = fbb_.StartTable();
7905 }
7906 ShapeOptionsBuilder &operator=(const ShapeOptionsBuilder &);
7907 flatbuffers::Offset<ShapeOptions> Finish() {
7908 const auto end = fbb_.EndTable(start_);
7909 auto o = flatbuffers::Offset<ShapeOptions>(end);
7910 return o;
7911 }
7912};
7913
7914inline flatbuffers::Offset<ShapeOptions> CreateShapeOptions(
7915 flatbuffers::FlatBufferBuilder &_fbb,
7916 tflite::TensorType out_type = tflite::TensorType_FLOAT32) {
7917 ShapeOptionsBuilder builder_(_fbb);
7918 builder_.add_out_type(out_type);
7919 return builder_.Finish();
7920}
7921
7922flatbuffers::Offset<ShapeOptions> CreateShapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7923
7924struct RankOptionsT : public flatbuffers::NativeTable {
7925 typedef RankOptions TableType;
7926 RankOptionsT() {
7927 }
7928};
7929
7930struct RankOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7931 typedef RankOptionsT NativeTableType;
7932 bool Verify(flatbuffers::Verifier &verifier) const {
7933 return VerifyTableStart(verifier) &&
7934 verifier.EndTable();
7935 }
7936 RankOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7937 void UnPackTo(RankOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7938 static flatbuffers::Offset<RankOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7939};
7940
7941struct RankOptionsBuilder {
7942 flatbuffers::FlatBufferBuilder &fbb_;
7943 flatbuffers::uoffset_t start_;
7944 explicit RankOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7945 : fbb_(_fbb) {
7946 start_ = fbb_.StartTable();
7947 }
7948 RankOptionsBuilder &operator=(const RankOptionsBuilder &);
7949 flatbuffers::Offset<RankOptions> Finish() {
7950 const auto end = fbb_.EndTable(start_);
7951 auto o = flatbuffers::Offset<RankOptions>(end);
7952 return o;
7953 }
7954};
7955
7956inline flatbuffers::Offset<RankOptions> CreateRankOptions(
7957 flatbuffers::FlatBufferBuilder &_fbb) {
7958 RankOptionsBuilder builder_(_fbb);
7959 return builder_.Finish();
7960}
7961
7962flatbuffers::Offset<RankOptions> CreateRankOptions(flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7963
7964struct PowOptionsT : public flatbuffers::NativeTable {
7965 typedef PowOptions TableType;
7966 PowOptionsT() {
7967 }
7968};
7969
7970struct PowOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7971 typedef PowOptionsT NativeTableType;
7972 bool Verify(flatbuffers::Verifier &verifier) const {
7973 return VerifyTableStart(verifier) &&
7974 verifier.EndTable();
7975 }
7976 PowOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7977 void UnPackTo(PowOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7978 static flatbuffers::Offset<PowOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7979};
7980
7981struct PowOptionsBuilder {
7982 flatbuffers::FlatBufferBuilder &fbb_;
7983 flatbuffers::uoffset_t start_;
7984 explicit PowOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7985 : fbb_(_fbb) {
7986 start_ = fbb_.StartTable();
7987 }
7988 PowOptionsBuilder &operator=(const PowOptionsBuilder &);
7989 flatbuffers::Offset<PowOptions> Finish() {
7990 const auto end = fbb_.EndTable(start_);
7991 auto o = flatbuffers::Offset<PowOptions>(end);
7992 return o;
7993 }
7994};
7995
7996inline flatbuffers::Offset<PowOptions> CreatePowOptions(
7997 flatbuffers::FlatBufferBuilder &_fbb) {
7998 PowOptionsBuilder builder_(_fbb);
7999 return builder_.Finish();
8000}
8001
8002flatbuffers::Offset<PowOptions> CreatePowOptions(flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8003
8004struct FakeQuantOptionsT : public flatbuffers::NativeTable {
8005 typedef FakeQuantOptions TableType;
8006 float min;
8007 float max;
8008 int32_t num_bits;
8009 bool narrow_range;
8010 FakeQuantOptionsT()
8011 : min(0.0f),
8012 max(0.0f),
8013 num_bits(0),
8014 narrow_range(false) {
8015 }
8016};
8017
8018struct FakeQuantOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8019 typedef FakeQuantOptionsT NativeTableType;
8020 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8021 VT_MIN = 4,
8022 VT_MAX = 6,
8023 VT_NUM_BITS = 8,
8024 VT_NARROW_RANGE = 10
8025 };
8026 float min() const {
8027 return GetField<float>(VT_MIN, 0.0f);
8028 }
8029 float max() const {
8030 return GetField<float>(VT_MAX, 0.0f);
8031 }
8032 int32_t num_bits() const {
8033 return GetField<int32_t>(VT_NUM_BITS, 0);
8034 }
8035 bool narrow_range() const {
8036 return GetField<uint8_t>(VT_NARROW_RANGE, 0) != 0;
8037 }
8038 bool Verify(flatbuffers::Verifier &verifier) const {
8039 return VerifyTableStart(verifier) &&
8040 VerifyField<float>(verifier, VT_MIN) &&
8041 VerifyField<float>(verifier, VT_MAX) &&
8042 VerifyField<int32_t>(verifier, VT_NUM_BITS) &&
8043 VerifyField<uint8_t>(verifier, VT_NARROW_RANGE) &&
8044 verifier.EndTable();
8045 }
8046 FakeQuantOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8047 void UnPackTo(FakeQuantOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8048 static flatbuffers::Offset<FakeQuantOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8049};
8050
8051struct FakeQuantOptionsBuilder {
8052 flatbuffers::FlatBufferBuilder &fbb_;
8053 flatbuffers::uoffset_t start_;
8054 void add_min(float min) {
8055 fbb_.AddElement<float>(FakeQuantOptions::VT_MIN, min, 0.0f);
8056 }
8057 void add_max(float max) {
8058 fbb_.AddElement<float>(FakeQuantOptions::VT_MAX, max, 0.0f);
8059 }
8060 void add_num_bits(int32_t num_bits) {
8061 fbb_.AddElement<int32_t>(FakeQuantOptions::VT_NUM_BITS, num_bits, 0);
8062 }
8063 void add_narrow_range(bool narrow_range) {
8064 fbb_.AddElement<uint8_t>(FakeQuantOptions::VT_NARROW_RANGE, static_cast<uint8_t>(narrow_range), 0);
8065 }
8066 explicit FakeQuantOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8067 : fbb_(_fbb) {
8068 start_ = fbb_.StartTable();
8069 }
8070 FakeQuantOptionsBuilder &operator=(const FakeQuantOptionsBuilder &);
8071 flatbuffers::Offset<FakeQuantOptions> Finish() {
8072 const auto end = fbb_.EndTable(start_);
8073 auto o = flatbuffers::Offset<FakeQuantOptions>(end);
8074 return o;
8075 }
8076};
8077
8078inline flatbuffers::Offset<FakeQuantOptions> CreateFakeQuantOptions(
8079 flatbuffers::FlatBufferBuilder &_fbb,
8080 float min = 0.0f,
8081 float max = 0.0f,
8082 int32_t num_bits = 0,
8083 bool narrow_range = false) {
8084 FakeQuantOptionsBuilder builder_(_fbb);
8085 builder_.add_num_bits(num_bits);
8086 builder_.add_max(max);
8087 builder_.add_min(min);
8088 builder_.add_narrow_range(narrow_range);
8089 return builder_.Finish();
8090}
8091
8092flatbuffers::Offset<FakeQuantOptions> CreateFakeQuantOptions(flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8093
8094struct PackOptionsT : public flatbuffers::NativeTable {
8095 typedef PackOptions TableType;
8096 int32_t values_count;
8097 int32_t axis;
8098 PackOptionsT()
8099 : values_count(0),
8100 axis(0) {
8101 }
8102};
8103
8104struct PackOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8105 typedef PackOptionsT NativeTableType;
8106 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8107 VT_VALUES_COUNT = 4,
8108 VT_AXIS = 6
8109 };
8110 int32_t values_count() const {
8111 return GetField<int32_t>(VT_VALUES_COUNT, 0);
8112 }
8113 int32_t axis() const {
8114 return GetField<int32_t>(VT_AXIS, 0);
8115 }
8116 bool Verify(flatbuffers::Verifier &verifier) const {
8117 return VerifyTableStart(verifier) &&
8118 VerifyField<int32_t>(verifier, VT_VALUES_COUNT) &&
8119 VerifyField<int32_t>(verifier, VT_AXIS) &&
8120 verifier.EndTable();
8121 }
8122 PackOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8123 void UnPackTo(PackOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8124 static flatbuffers::Offset<PackOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8125};
8126
8127struct PackOptionsBuilder {
8128 flatbuffers::FlatBufferBuilder &fbb_;
8129 flatbuffers::uoffset_t start_;
8130 void add_values_count(int32_t values_count) {
8131 fbb_.AddElement<int32_t>(PackOptions::VT_VALUES_COUNT, values_count, 0);
8132 }
8133 void add_axis(int32_t axis) {
8134 fbb_.AddElement<int32_t>(PackOptions::VT_AXIS, axis, 0);
8135 }
8136 explicit PackOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8137 : fbb_(_fbb) {
8138 start_ = fbb_.StartTable();
8139 }
8140 PackOptionsBuilder &operator=(const PackOptionsBuilder &);
8141 flatbuffers::Offset<PackOptions> Finish() {
8142 const auto end = fbb_.EndTable(start_);
8143 auto o = flatbuffers::Offset<PackOptions>(end);
8144 return o;
8145 }
8146};
8147
8148inline flatbuffers::Offset<PackOptions> CreatePackOptions(
8149 flatbuffers::FlatBufferBuilder &_fbb,
8150 int32_t values_count = 0,
8151 int32_t axis = 0) {
8152 PackOptionsBuilder builder_(_fbb);
8153 builder_.add_axis(axis);
8154 builder_.add_values_count(values_count);
8155 return builder_.Finish();
8156}
8157
8158flatbuffers::Offset<PackOptions> CreatePackOptions(flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8159
8160struct LogicalOrOptionsT : public flatbuffers::NativeTable {
8161 typedef LogicalOrOptions TableType;
8162 LogicalOrOptionsT() {
8163 }
8164};
8165
8166struct LogicalOrOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8167 typedef LogicalOrOptionsT NativeTableType;
8168 bool Verify(flatbuffers::Verifier &verifier) const {
8169 return VerifyTableStart(verifier) &&
8170 verifier.EndTable();
8171 }
8172 LogicalOrOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8173 void UnPackTo(LogicalOrOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8174 static flatbuffers::Offset<LogicalOrOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8175};
8176
8177struct LogicalOrOptionsBuilder {
8178 flatbuffers::FlatBufferBuilder &fbb_;
8179 flatbuffers::uoffset_t start_;
8180 explicit LogicalOrOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8181 : fbb_(_fbb) {
8182 start_ = fbb_.StartTable();
8183 }
8184 LogicalOrOptionsBuilder &operator=(const LogicalOrOptionsBuilder &);
8185 flatbuffers::Offset<LogicalOrOptions> Finish() {
8186 const auto end = fbb_.EndTable(start_);
8187 auto o = flatbuffers::Offset<LogicalOrOptions>(end);
8188 return o;
8189 }
8190};
8191
8192inline flatbuffers::Offset<LogicalOrOptions> CreateLogicalOrOptions(
8193 flatbuffers::FlatBufferBuilder &_fbb) {
8194 LogicalOrOptionsBuilder builder_(_fbb);
8195 return builder_.Finish();
8196}
8197
8198flatbuffers::Offset<LogicalOrOptions> CreateLogicalOrOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8199
8200struct OneHotOptionsT : public flatbuffers::NativeTable {
8201 typedef OneHotOptions TableType;
8202 int32_t axis;
8203 OneHotOptionsT()
8204 : axis(0) {
8205 }
8206};
8207
8208struct OneHotOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8209 typedef OneHotOptionsT NativeTableType;
8210 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8211 VT_AXIS = 4
8212 };
8213 int32_t axis() const {
8214 return GetField<int32_t>(VT_AXIS, 0);
8215 }
8216 bool Verify(flatbuffers::Verifier &verifier) const {
8217 return VerifyTableStart(verifier) &&
8218 VerifyField<int32_t>(verifier, VT_AXIS) &&
8219 verifier.EndTable();
8220 }
8221 OneHotOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8222 void UnPackTo(OneHotOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8223 static flatbuffers::Offset<OneHotOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8224};
8225
8226struct OneHotOptionsBuilder {
8227 flatbuffers::FlatBufferBuilder &fbb_;
8228 flatbuffers::uoffset_t start_;
8229 void add_axis(int32_t axis) {
8230 fbb_.AddElement<int32_t>(OneHotOptions::VT_AXIS, axis, 0);
8231 }
8232 explicit OneHotOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8233 : fbb_(_fbb) {
8234 start_ = fbb_.StartTable();
8235 }
8236 OneHotOptionsBuilder &operator=(const OneHotOptionsBuilder &);
8237 flatbuffers::Offset<OneHotOptions> Finish() {
8238 const auto end = fbb_.EndTable(start_);
8239 auto o = flatbuffers::Offset<OneHotOptions>(end);
8240 return o;
8241 }
8242};
8243
8244inline flatbuffers::Offset<OneHotOptions> CreateOneHotOptions(
8245 flatbuffers::FlatBufferBuilder &_fbb,
8246 int32_t axis = 0) {
8247 OneHotOptionsBuilder builder_(_fbb);
8248 builder_.add_axis(axis);
8249 return builder_.Finish();
8250}
8251
8252flatbuffers::Offset<OneHotOptions> CreateOneHotOptions(flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8253
8254struct AbsOptionsT : public flatbuffers::NativeTable {
8255 typedef AbsOptions TableType;
8256 AbsOptionsT() {
8257 }
8258};
8259
8260struct AbsOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8261 typedef AbsOptionsT NativeTableType;
8262 bool Verify(flatbuffers::Verifier &verifier) const {
8263 return VerifyTableStart(verifier) &&
8264 verifier.EndTable();
8265 }
8266 AbsOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8267 void UnPackTo(AbsOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8268 static flatbuffers::Offset<AbsOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8269};
8270
8271struct AbsOptionsBuilder {
8272 flatbuffers::FlatBufferBuilder &fbb_;
8273 flatbuffers::uoffset_t start_;
8274 explicit AbsOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8275 : fbb_(_fbb) {
8276 start_ = fbb_.StartTable();
8277 }
8278 AbsOptionsBuilder &operator=(const AbsOptionsBuilder &);
8279 flatbuffers::Offset<AbsOptions> Finish() {
8280 const auto end = fbb_.EndTable(start_);
8281 auto o = flatbuffers::Offset<AbsOptions>(end);
8282 return o;
8283 }
8284};
8285
8286inline flatbuffers::Offset<AbsOptions> CreateAbsOptions(
8287 flatbuffers::FlatBufferBuilder &_fbb) {
8288 AbsOptionsBuilder builder_(_fbb);
8289 return builder_.Finish();
8290}
8291
8292flatbuffers::Offset<AbsOptions> CreateAbsOptions(flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8293
8294struct HardSwishOptionsT : public flatbuffers::NativeTable {
8295 typedef HardSwishOptions TableType;
8296 HardSwishOptionsT() {
8297 }
8298};
8299
8300struct HardSwishOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8301 typedef HardSwishOptionsT NativeTableType;
8302 bool Verify(flatbuffers::Verifier &verifier) const {
8303 return VerifyTableStart(verifier) &&
8304 verifier.EndTable();
8305 }
8306 HardSwishOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8307 void UnPackTo(HardSwishOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8308 static flatbuffers::Offset<HardSwishOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HardSwishOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8309};
8310
8311struct HardSwishOptionsBuilder {
8312 flatbuffers::FlatBufferBuilder &fbb_;
8313 flatbuffers::uoffset_t start_;
8314 explicit HardSwishOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8315 : fbb_(_fbb) {
8316 start_ = fbb_.StartTable();
8317 }
8318 HardSwishOptionsBuilder &operator=(const HardSwishOptionsBuilder &);
8319 flatbuffers::Offset<HardSwishOptions> Finish() {
8320 const auto end = fbb_.EndTable(start_);
8321 auto o = flatbuffers::Offset<HardSwishOptions>(end);
8322 return o;
8323 }
8324};
8325
8326inline flatbuffers::Offset<HardSwishOptions> CreateHardSwishOptions(
8327 flatbuffers::FlatBufferBuilder &_fbb) {
8328 HardSwishOptionsBuilder builder_(_fbb);
8329 return builder_.Finish();
8330}
8331
8332flatbuffers::Offset<HardSwishOptions> CreateHardSwishOptions(flatbuffers::FlatBufferBuilder &_fbb, const HardSwishOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8333
8334struct LogicalAndOptionsT : public flatbuffers::NativeTable {
8335 typedef LogicalAndOptions TableType;
8336 LogicalAndOptionsT() {
8337 }
8338};
8339
8340struct LogicalAndOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8341 typedef LogicalAndOptionsT NativeTableType;
8342 bool Verify(flatbuffers::Verifier &verifier) const {
8343 return VerifyTableStart(verifier) &&
8344 verifier.EndTable();
8345 }
8346 LogicalAndOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8347 void UnPackTo(LogicalAndOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8348 static flatbuffers::Offset<LogicalAndOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8349};
8350
8351struct LogicalAndOptionsBuilder {
8352 flatbuffers::FlatBufferBuilder &fbb_;
8353 flatbuffers::uoffset_t start_;
8354 explicit LogicalAndOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8355 : fbb_(_fbb) {
8356 start_ = fbb_.StartTable();
8357 }
8358 LogicalAndOptionsBuilder &operator=(const LogicalAndOptionsBuilder &);
8359 flatbuffers::Offset<LogicalAndOptions> Finish() {
8360 const auto end = fbb_.EndTable(start_);
8361 auto o = flatbuffers::Offset<LogicalAndOptions>(end);
8362 return o;
8363 }
8364};
8365
8366inline flatbuffers::Offset<LogicalAndOptions> CreateLogicalAndOptions(
8367 flatbuffers::FlatBufferBuilder &_fbb) {
8368 LogicalAndOptionsBuilder builder_(_fbb);
8369 return builder_.Finish();
8370}
8371
8372flatbuffers::Offset<LogicalAndOptions> CreateLogicalAndOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8373
8374struct LogicalNotOptionsT : public flatbuffers::NativeTable {
8375 typedef LogicalNotOptions TableType;
8376 LogicalNotOptionsT() {
8377 }
8378};
8379
8380struct LogicalNotOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8381 typedef LogicalNotOptionsT NativeTableType;
8382 bool Verify(flatbuffers::Verifier &verifier) const {
8383 return VerifyTableStart(verifier) &&
8384 verifier.EndTable();
8385 }
8386 LogicalNotOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8387 void UnPackTo(LogicalNotOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8388 static flatbuffers::Offset<LogicalNotOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8389};
8390
8391struct LogicalNotOptionsBuilder {
8392 flatbuffers::FlatBufferBuilder &fbb_;
8393 flatbuffers::uoffset_t start_;
8394 explicit LogicalNotOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8395 : fbb_(_fbb) {
8396 start_ = fbb_.StartTable();
8397 }
8398 LogicalNotOptionsBuilder &operator=(const LogicalNotOptionsBuilder &);
8399 flatbuffers::Offset<LogicalNotOptions> Finish() {
8400 const auto end = fbb_.EndTable(start_);
8401 auto o = flatbuffers::Offset<LogicalNotOptions>(end);
8402 return o;
8403 }
8404};
8405
8406inline flatbuffers::Offset<LogicalNotOptions> CreateLogicalNotOptions(
8407 flatbuffers::FlatBufferBuilder &_fbb) {
8408 LogicalNotOptionsBuilder builder_(_fbb);
8409 return builder_.Finish();
8410}
8411
8412flatbuffers::Offset<LogicalNotOptions> CreateLogicalNotOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8413
8414struct UnpackOptionsT : public flatbuffers::NativeTable {
8415 typedef UnpackOptions TableType;
8416 int32_t num;
8417 int32_t axis;
8418 UnpackOptionsT()
8419 : num(0),
8420 axis(0) {
8421 }
8422};
8423
8424struct UnpackOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8425 typedef UnpackOptionsT NativeTableType;
8426 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8427 VT_NUM = 4,
8428 VT_AXIS = 6
8429 };
8430 int32_t num() const {
8431 return GetField<int32_t>(VT_NUM, 0);
8432 }
8433 int32_t axis() const {
8434 return GetField<int32_t>(VT_AXIS, 0);
8435 }
8436 bool Verify(flatbuffers::Verifier &verifier) const {
8437 return VerifyTableStart(verifier) &&
8438 VerifyField<int32_t>(verifier, VT_NUM) &&
8439 VerifyField<int32_t>(verifier, VT_AXIS) &&
8440 verifier.EndTable();
8441 }
8442 UnpackOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8443 void UnPackTo(UnpackOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8444 static flatbuffers::Offset<UnpackOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8445};
8446
8447struct UnpackOptionsBuilder {
8448 flatbuffers::FlatBufferBuilder &fbb_;
8449 flatbuffers::uoffset_t start_;
8450 void add_num(int32_t num) {
8451 fbb_.AddElement<int32_t>(UnpackOptions::VT_NUM, num, 0);
8452 }
8453 void add_axis(int32_t axis) {
8454 fbb_.AddElement<int32_t>(UnpackOptions::VT_AXIS, axis, 0);
8455 }
8456 explicit UnpackOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8457 : fbb_(_fbb) {
8458 start_ = fbb_.StartTable();
8459 }
8460 UnpackOptionsBuilder &operator=(const UnpackOptionsBuilder &);
8461 flatbuffers::Offset<UnpackOptions> Finish() {
8462 const auto end = fbb_.EndTable(start_);
8463 auto o = flatbuffers::Offset<UnpackOptions>(end);
8464 return o;
8465 }
8466};
8467
8468inline flatbuffers::Offset<UnpackOptions> CreateUnpackOptions(
8469 flatbuffers::FlatBufferBuilder &_fbb,
8470 int32_t num = 0,
8471 int32_t axis = 0) {
8472 UnpackOptionsBuilder builder_(_fbb);
8473 builder_.add_axis(axis);
8474 builder_.add_num(num);
8475 return builder_.Finish();
8476}
8477
8478flatbuffers::Offset<UnpackOptions> CreateUnpackOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8479
8480struct FloorDivOptionsT : public flatbuffers::NativeTable {
8481 typedef FloorDivOptions TableType;
8482 FloorDivOptionsT() {
8483 }
8484};
8485
8486struct FloorDivOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8487 typedef FloorDivOptionsT NativeTableType;
8488 bool Verify(flatbuffers::Verifier &verifier) const {
8489 return VerifyTableStart(verifier) &&
8490 verifier.EndTable();
8491 }
8492 FloorDivOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8493 void UnPackTo(FloorDivOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8494 static flatbuffers::Offset<FloorDivOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8495};
8496
8497struct FloorDivOptionsBuilder {
8498 flatbuffers::FlatBufferBuilder &fbb_;
8499 flatbuffers::uoffset_t start_;
8500 explicit FloorDivOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8501 : fbb_(_fbb) {
8502 start_ = fbb_.StartTable();
8503 }
8504 FloorDivOptionsBuilder &operator=(const FloorDivOptionsBuilder &);
8505 flatbuffers::Offset<FloorDivOptions> Finish() {
8506 const auto end = fbb_.EndTable(start_);
8507 auto o = flatbuffers::Offset<FloorDivOptions>(end);
8508 return o;
8509 }
8510};
8511
8512inline flatbuffers::Offset<FloorDivOptions> CreateFloorDivOptions(
8513 flatbuffers::FlatBufferBuilder &_fbb) {
8514 FloorDivOptionsBuilder builder_(_fbb);
8515 return builder_.Finish();
8516}
8517
8518flatbuffers::Offset<FloorDivOptions> CreateFloorDivOptions(flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8519
8520struct SquareOptionsT : public flatbuffers::NativeTable {
8521 typedef SquareOptions TableType;
8522 SquareOptionsT() {
8523 }
8524};
8525
8526struct SquareOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8527 typedef SquareOptionsT NativeTableType;
8528 bool Verify(flatbuffers::Verifier &verifier) const {
8529 return VerifyTableStart(verifier) &&
8530 verifier.EndTable();
8531 }
8532 SquareOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8533 void UnPackTo(SquareOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8534 static flatbuffers::Offset<SquareOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8535};
8536
8537struct SquareOptionsBuilder {
8538 flatbuffers::FlatBufferBuilder &fbb_;
8539 flatbuffers::uoffset_t start_;
8540 explicit SquareOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8541 : fbb_(_fbb) {
8542 start_ = fbb_.StartTable();
8543 }
8544 SquareOptionsBuilder &operator=(const SquareOptionsBuilder &);
8545 flatbuffers::Offset<SquareOptions> Finish() {
8546 const auto end = fbb_.EndTable(start_);
8547 auto o = flatbuffers::Offset<SquareOptions>(end);
8548 return o;
8549 }
8550};
8551
8552inline flatbuffers::Offset<SquareOptions> CreateSquareOptions(
8553 flatbuffers::FlatBufferBuilder &_fbb) {
8554 SquareOptionsBuilder builder_(_fbb);
8555 return builder_.Finish();
8556}
8557
8558flatbuffers::Offset<SquareOptions> CreateSquareOptions(flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8559
8560struct ZerosLikeOptionsT : public flatbuffers::NativeTable {
8561 typedef ZerosLikeOptions TableType;
8562 ZerosLikeOptionsT() {
8563 }
8564};
8565
8566struct ZerosLikeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8567 typedef ZerosLikeOptionsT NativeTableType;
8568 bool Verify(flatbuffers::Verifier &verifier) const {
8569 return VerifyTableStart(verifier) &&
8570 verifier.EndTable();
8571 }
8572 ZerosLikeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8573 void UnPackTo(ZerosLikeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8574 static flatbuffers::Offset<ZerosLikeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8575};
8576
8577struct ZerosLikeOptionsBuilder {
8578 flatbuffers::FlatBufferBuilder &fbb_;
8579 flatbuffers::uoffset_t start_;
8580 explicit ZerosLikeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8581 : fbb_(_fbb) {
8582 start_ = fbb_.StartTable();
8583 }
8584 ZerosLikeOptionsBuilder &operator=(const ZerosLikeOptionsBuilder &);
8585 flatbuffers::Offset<ZerosLikeOptions> Finish() {
8586 const auto end = fbb_.EndTable(start_);
8587 auto o = flatbuffers::Offset<ZerosLikeOptions>(end);
8588 return o;
8589 }
8590};
8591
8592inline flatbuffers::Offset<ZerosLikeOptions> CreateZerosLikeOptions(
8593 flatbuffers::FlatBufferBuilder &_fbb) {
8594 ZerosLikeOptionsBuilder builder_(_fbb);
8595 return builder_.Finish();
8596}
8597
8598flatbuffers::Offset<ZerosLikeOptions> CreateZerosLikeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8599
8600struct FillOptionsT : public flatbuffers::NativeTable {
8601 typedef FillOptions TableType;
8602 FillOptionsT() {
8603 }
8604};
8605
8606struct FillOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8607 typedef FillOptionsT NativeTableType;
8608 bool Verify(flatbuffers::Verifier &verifier) const {
8609 return VerifyTableStart(verifier) &&
8610 verifier.EndTable();
8611 }
8612 FillOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8613 void UnPackTo(FillOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8614 static flatbuffers::Offset<FillOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8615};
8616
8617struct FillOptionsBuilder {
8618 flatbuffers::FlatBufferBuilder &fbb_;
8619 flatbuffers::uoffset_t start_;
8620 explicit FillOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8621 : fbb_(_fbb) {
8622 start_ = fbb_.StartTable();
8623 }
8624 FillOptionsBuilder &operator=(const FillOptionsBuilder &);
8625 flatbuffers::Offset<FillOptions> Finish() {
8626 const auto end = fbb_.EndTable(start_);
8627 auto o = flatbuffers::Offset<FillOptions>(end);
8628 return o;
8629 }
8630};
8631
8632inline flatbuffers::Offset<FillOptions> CreateFillOptions(
8633 flatbuffers::FlatBufferBuilder &_fbb) {
8634 FillOptionsBuilder builder_(_fbb);
8635 return builder_.Finish();
8636}
8637
8638flatbuffers::Offset<FillOptions> CreateFillOptions(flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8639
8640struct FloorModOptionsT : public flatbuffers::NativeTable {
8641 typedef FloorModOptions TableType;
8642 FloorModOptionsT() {
8643 }
8644};
8645
8646struct FloorModOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8647 typedef FloorModOptionsT NativeTableType;
8648 bool Verify(flatbuffers::Verifier &verifier) const {
8649 return VerifyTableStart(verifier) &&
8650 verifier.EndTable();
8651 }
8652 FloorModOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8653 void UnPackTo(FloorModOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8654 static flatbuffers::Offset<FloorModOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8655};
8656
8657struct FloorModOptionsBuilder {
8658 flatbuffers::FlatBufferBuilder &fbb_;
8659 flatbuffers::uoffset_t start_;
8660 explicit FloorModOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8661 : fbb_(_fbb) {
8662 start_ = fbb_.StartTable();
8663 }
8664 FloorModOptionsBuilder &operator=(const FloorModOptionsBuilder &);
8665 flatbuffers::Offset<FloorModOptions> Finish() {
8666 const auto end = fbb_.EndTable(start_);
8667 auto o = flatbuffers::Offset<FloorModOptions>(end);
8668 return o;
8669 }
8670};
8671
8672inline flatbuffers::Offset<FloorModOptions> CreateFloorModOptions(
8673 flatbuffers::FlatBufferBuilder &_fbb) {
8674 FloorModOptionsBuilder builder_(_fbb);
8675 return builder_.Finish();
8676}
8677
8678flatbuffers::Offset<FloorModOptions> CreateFloorModOptions(flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8679
8680struct RangeOptionsT : public flatbuffers::NativeTable {
8681 typedef RangeOptions TableType;
8682 RangeOptionsT() {
8683 }
8684};
8685
8686struct RangeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8687 typedef RangeOptionsT NativeTableType;
8688 bool Verify(flatbuffers::Verifier &verifier) const {
8689 return VerifyTableStart(verifier) &&
8690 verifier.EndTable();
8691 }
8692 RangeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8693 void UnPackTo(RangeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8694 static flatbuffers::Offset<RangeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8695};
8696
8697struct RangeOptionsBuilder {
8698 flatbuffers::FlatBufferBuilder &fbb_;
8699 flatbuffers::uoffset_t start_;
8700 explicit RangeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8701 : fbb_(_fbb) {
8702 start_ = fbb_.StartTable();
8703 }
8704 RangeOptionsBuilder &operator=(const RangeOptionsBuilder &);
8705 flatbuffers::Offset<RangeOptions> Finish() {
8706 const auto end = fbb_.EndTable(start_);
8707 auto o = flatbuffers::Offset<RangeOptions>(end);
8708 return o;
8709 }
8710};
8711
8712inline flatbuffers::Offset<RangeOptions> CreateRangeOptions(
8713 flatbuffers::FlatBufferBuilder &_fbb) {
8714 RangeOptionsBuilder builder_(_fbb);
8715 return builder_.Finish();
8716}
8717
8718flatbuffers::Offset<RangeOptions> CreateRangeOptions(flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8719
8720struct LeakyReluOptionsT : public flatbuffers::NativeTable {
8721 typedef LeakyReluOptions TableType;
8722 float alpha;
8723 LeakyReluOptionsT()
8724 : alpha(0.0f) {
8725 }
8726};
8727
8728struct LeakyReluOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8729 typedef LeakyReluOptionsT NativeTableType;
8730 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8731 VT_ALPHA = 4
8732 };
8733 float alpha() const {
8734 return GetField<float>(VT_ALPHA, 0.0f);
8735 }
8736 bool Verify(flatbuffers::Verifier &verifier) const {
8737 return VerifyTableStart(verifier) &&
8738 VerifyField<float>(verifier, VT_ALPHA) &&
8739 verifier.EndTable();
8740 }
8741 LeakyReluOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8742 void UnPackTo(LeakyReluOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8743 static flatbuffers::Offset<LeakyReluOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8744};
8745
8746struct LeakyReluOptionsBuilder {
8747 flatbuffers::FlatBufferBuilder &fbb_;
8748 flatbuffers::uoffset_t start_;
8749 void add_alpha(float alpha) {
8750 fbb_.AddElement<float>(LeakyReluOptions::VT_ALPHA, alpha, 0.0f);
8751 }
8752 explicit LeakyReluOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8753 : fbb_(_fbb) {
8754 start_ = fbb_.StartTable();
8755 }
8756 LeakyReluOptionsBuilder &operator=(const LeakyReluOptionsBuilder &);
8757 flatbuffers::Offset<LeakyReluOptions> Finish() {
8758 const auto end = fbb_.EndTable(start_);
8759 auto o = flatbuffers::Offset<LeakyReluOptions>(end);
8760 return o;
8761 }
8762};
8763
8764inline flatbuffers::Offset<LeakyReluOptions> CreateLeakyReluOptions(
8765 flatbuffers::FlatBufferBuilder &_fbb,
8766 float alpha = 0.0f) {
8767 LeakyReluOptionsBuilder builder_(_fbb);
8768 builder_.add_alpha(alpha);
8769 return builder_.Finish();
8770}
8771
8772flatbuffers::Offset<LeakyReluOptions> CreateLeakyReluOptions(flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8773
8774struct SquaredDifferenceOptionsT : public flatbuffers::NativeTable {
8775 typedef SquaredDifferenceOptions TableType;
8776 SquaredDifferenceOptionsT() {
8777 }
8778};
8779
8780struct SquaredDifferenceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8781 typedef SquaredDifferenceOptionsT NativeTableType;
8782 bool Verify(flatbuffers::Verifier &verifier) const {
8783 return VerifyTableStart(verifier) &&
8784 verifier.EndTable();
8785 }
8786 SquaredDifferenceOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8787 void UnPackTo(SquaredDifferenceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8788 static flatbuffers::Offset<SquaredDifferenceOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8789};
8790
8791struct SquaredDifferenceOptionsBuilder {
8792 flatbuffers::FlatBufferBuilder &fbb_;
8793 flatbuffers::uoffset_t start_;
8794 explicit SquaredDifferenceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8795 : fbb_(_fbb) {
8796 start_ = fbb_.StartTable();
8797 }
8798 SquaredDifferenceOptionsBuilder &operator=(const SquaredDifferenceOptionsBuilder &);
8799 flatbuffers::Offset<SquaredDifferenceOptions> Finish() {
8800 const auto end = fbb_.EndTable(start_);
8801 auto o = flatbuffers::Offset<SquaredDifferenceOptions>(end);
8802 return o;
8803 }
8804};
8805
8806inline flatbuffers::Offset<SquaredDifferenceOptions> CreateSquaredDifferenceOptions(
8807 flatbuffers::FlatBufferBuilder &_fbb) {
8808 SquaredDifferenceOptionsBuilder builder_(_fbb);
8809 return builder_.Finish();
8810}
8811
8812flatbuffers::Offset<SquaredDifferenceOptions> CreateSquaredDifferenceOptions(flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8813
8814struct MirrorPadOptionsT : public flatbuffers::NativeTable {
8815 typedef MirrorPadOptions TableType;
8816 tflite::MirrorPadMode mode;
8817 MirrorPadOptionsT()
8818 : mode(tflite::MirrorPadMode_REFLECT) {
8819 }
8820};
8821
8822struct MirrorPadOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8823 typedef MirrorPadOptionsT NativeTableType;
8824 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8825 VT_MODE = 4
8826 };
8827 tflite::MirrorPadMode mode() const {
8828 return static_cast<tflite::MirrorPadMode>(GetField<int8_t>(VT_MODE, 0));
8829 }
8830 bool Verify(flatbuffers::Verifier &verifier) const {
8831 return VerifyTableStart(verifier) &&
8832 VerifyField<int8_t>(verifier, VT_MODE) &&
8833 verifier.EndTable();
8834 }
8835 MirrorPadOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8836 void UnPackTo(MirrorPadOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8837 static flatbuffers::Offset<MirrorPadOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8838};
8839
8840struct MirrorPadOptionsBuilder {
8841 flatbuffers::FlatBufferBuilder &fbb_;
8842 flatbuffers::uoffset_t start_;
8843 void add_mode(tflite::MirrorPadMode mode) {
8844 fbb_.AddElement<int8_t>(MirrorPadOptions::VT_MODE, static_cast<int8_t>(mode), 0);
8845 }
8846 explicit MirrorPadOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8847 : fbb_(_fbb) {
8848 start_ = fbb_.StartTable();
8849 }
8850 MirrorPadOptionsBuilder &operator=(const MirrorPadOptionsBuilder &);
8851 flatbuffers::Offset<MirrorPadOptions> Finish() {
8852 const auto end = fbb_.EndTable(start_);
8853 auto o = flatbuffers::Offset<MirrorPadOptions>(end);
8854 return o;
8855 }
8856};
8857
8858inline flatbuffers::Offset<MirrorPadOptions> CreateMirrorPadOptions(
8859 flatbuffers::FlatBufferBuilder &_fbb,
8860 tflite::MirrorPadMode mode = tflite::MirrorPadMode_REFLECT) {
8861 MirrorPadOptionsBuilder builder_(_fbb);
8862 builder_.add_mode(mode);
8863 return builder_.Finish();
8864}
8865
8866flatbuffers::Offset<MirrorPadOptions> CreateMirrorPadOptions(flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8867
8868struct UniqueOptionsT : public flatbuffers::NativeTable {
8869 typedef UniqueOptions TableType;
8870 tflite::TensorType idx_out_type;
8871 UniqueOptionsT()
8872 : idx_out_type(tflite::TensorType_INT32) {
8873 }
8874};
8875
8876struct UniqueOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8877 typedef UniqueOptionsT NativeTableType;
8878 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8879 VT_IDX_OUT_TYPE = 4
8880 };
8881 tflite::TensorType idx_out_type() const {
8882 return static_cast<tflite::TensorType>(GetField<int8_t>(VT_IDX_OUT_TYPE, 2));
8883 }
8884 bool Verify(flatbuffers::Verifier &verifier) const {
8885 return VerifyTableStart(verifier) &&
8886 VerifyField<int8_t>(verifier, VT_IDX_OUT_TYPE) &&
8887 verifier.EndTable();
8888 }
8889 UniqueOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8890 void UnPackTo(UniqueOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8891 static flatbuffers::Offset<UniqueOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8892};
8893
8894struct UniqueOptionsBuilder {
8895 flatbuffers::FlatBufferBuilder &fbb_;
8896 flatbuffers::uoffset_t start_;
8897 void add_idx_out_type(tflite::TensorType idx_out_type) {
8898 fbb_.AddElement<int8_t>(UniqueOptions::VT_IDX_OUT_TYPE, static_cast<int8_t>(idx_out_type), 2);
8899 }
8900 explicit UniqueOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8901 : fbb_(_fbb) {
8902 start_ = fbb_.StartTable();
8903 }
8904 UniqueOptionsBuilder &operator=(const UniqueOptionsBuilder &);
8905 flatbuffers::Offset<UniqueOptions> Finish() {
8906 const auto end = fbb_.EndTable(start_);
8907 auto o = flatbuffers::Offset<UniqueOptions>(end);
8908 return o;
8909 }
8910};
8911
8912inline flatbuffers::Offset<UniqueOptions> CreateUniqueOptions(
8913 flatbuffers::FlatBufferBuilder &_fbb,
8914 tflite::TensorType idx_out_type = tflite::TensorType_INT32) {
8915 UniqueOptionsBuilder builder_(_fbb);
8916 builder_.add_idx_out_type(idx_out_type);
8917 return builder_.Finish();
8918}
8919
8920flatbuffers::Offset<UniqueOptions> CreateUniqueOptions(flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8921
8922struct ReverseV2OptionsT : public flatbuffers::NativeTable {
8923 typedef ReverseV2Options TableType;
8924 ReverseV2OptionsT() {
8925 }
8926};
8927
8928struct ReverseV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8929 typedef ReverseV2OptionsT NativeTableType;
8930 bool Verify(flatbuffers::Verifier &verifier) const {
8931 return VerifyTableStart(verifier) &&
8932 verifier.EndTable();
8933 }
8934 ReverseV2OptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8935 void UnPackTo(ReverseV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8936 static flatbuffers::Offset<ReverseV2Options> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8937};
8938
8939struct ReverseV2OptionsBuilder {
8940 flatbuffers::FlatBufferBuilder &fbb_;
8941 flatbuffers::uoffset_t start_;
8942 explicit ReverseV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8943 : fbb_(_fbb) {
8944 start_ = fbb_.StartTable();
8945 }
8946 ReverseV2OptionsBuilder &operator=(const ReverseV2OptionsBuilder &);
8947 flatbuffers::Offset<ReverseV2Options> Finish() {
8948 const auto end = fbb_.EndTable(start_);
8949 auto o = flatbuffers::Offset<ReverseV2Options>(end);
8950 return o;
8951 }
8952};
8953
8954inline flatbuffers::Offset<ReverseV2Options> CreateReverseV2Options(
8955 flatbuffers::FlatBufferBuilder &_fbb) {
8956 ReverseV2OptionsBuilder builder_(_fbb);
8957 return builder_.Finish();
8958}
8959
8960flatbuffers::Offset<ReverseV2Options> CreateReverseV2Options(flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8961
8962struct AddNOptionsT : public flatbuffers::NativeTable {
8963 typedef AddNOptions TableType;
8964 AddNOptionsT() {
8965 }
8966};
8967
8968struct AddNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8969 typedef AddNOptionsT NativeTableType;
8970 bool Verify(flatbuffers::Verifier &verifier) const {
8971 return VerifyTableStart(verifier) &&
8972 verifier.EndTable();
8973 }
8974 AddNOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8975 void UnPackTo(AddNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8976 static flatbuffers::Offset<AddNOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8977};
8978
8979struct AddNOptionsBuilder {
8980 flatbuffers::FlatBufferBuilder &fbb_;
8981 flatbuffers::uoffset_t start_;
8982 explicit AddNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8983 : fbb_(_fbb) {
8984 start_ = fbb_.StartTable();
8985 }
8986 AddNOptionsBuilder &operator=(const AddNOptionsBuilder &);
8987 flatbuffers::Offset<AddNOptions> Finish() {
8988 const auto end = fbb_.EndTable(start_);
8989 auto o = flatbuffers::Offset<AddNOptions>(end);
8990 return o;
8991 }
8992};
8993
8994inline flatbuffers::Offset<AddNOptions> CreateAddNOptions(
8995 flatbuffers::FlatBufferBuilder &_fbb) {
8996 AddNOptionsBuilder builder_(_fbb);
8997 return builder_.Finish();
8998}
8999
9000flatbuffers::Offset<AddNOptions> CreateAddNOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9001
9002struct GatherNdOptionsT : public flatbuffers::NativeTable {
9003 typedef GatherNdOptions TableType;
9004 GatherNdOptionsT() {
9005 }
9006};
9007
9008struct GatherNdOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9009 typedef GatherNdOptionsT NativeTableType;
9010 bool Verify(flatbuffers::Verifier &verifier) const {
9011 return VerifyTableStart(verifier) &&
9012 verifier.EndTable();
9013 }
9014 GatherNdOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9015 void UnPackTo(GatherNdOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9016 static flatbuffers::Offset<GatherNdOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9017};
9018
9019struct GatherNdOptionsBuilder {
9020 flatbuffers::FlatBufferBuilder &fbb_;
9021 flatbuffers::uoffset_t start_;
9022 explicit GatherNdOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9023 : fbb_(_fbb) {
9024 start_ = fbb_.StartTable();
9025 }
9026 GatherNdOptionsBuilder &operator=(const GatherNdOptionsBuilder &);
9027 flatbuffers::Offset<GatherNdOptions> Finish() {
9028 const auto end = fbb_.EndTable(start_);
9029 auto o = flatbuffers::Offset<GatherNdOptions>(end);
9030 return o;
9031 }
9032};
9033
9034inline flatbuffers::Offset<GatherNdOptions> CreateGatherNdOptions(
9035 flatbuffers::FlatBufferBuilder &_fbb) {
9036 GatherNdOptionsBuilder builder_(_fbb);
9037 return builder_.Finish();
9038}
9039
9040flatbuffers::Offset<GatherNdOptions> CreateGatherNdOptions(flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9041
9042struct WhereOptionsT : public flatbuffers::NativeTable {
9043 typedef WhereOptions TableType;
9044 WhereOptionsT() {
9045 }
9046};
9047
9048struct WhereOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9049 typedef WhereOptionsT NativeTableType;
9050 bool Verify(flatbuffers::Verifier &verifier) const {
9051 return VerifyTableStart(verifier) &&
9052 verifier.EndTable();
9053 }
9054 WhereOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9055 void UnPackTo(WhereOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9056 static flatbuffers::Offset<WhereOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9057};
9058
9059struct WhereOptionsBuilder {
9060 flatbuffers::FlatBufferBuilder &fbb_;
9061 flatbuffers::uoffset_t start_;
9062 explicit WhereOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9063 : fbb_(_fbb) {
9064 start_ = fbb_.StartTable();
9065 }
9066 WhereOptionsBuilder &operator=(const WhereOptionsBuilder &);
9067 flatbuffers::Offset<WhereOptions> Finish() {
9068 const auto end = fbb_.EndTable(start_);
9069 auto o = flatbuffers::Offset<WhereOptions>(end);
9070 return o;
9071 }
9072};
9073
9074inline flatbuffers::Offset<WhereOptions> CreateWhereOptions(
9075 flatbuffers::FlatBufferBuilder &_fbb) {
9076 WhereOptionsBuilder builder_(_fbb);
9077 return builder_.Finish();
9078}
9079
9080flatbuffers::Offset<WhereOptions> CreateWhereOptions(flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9081
9082struct ReverseSequenceOptionsT : public flatbuffers::NativeTable {
9083 typedef ReverseSequenceOptions TableType;
9084 int32_t seq_dim;
9085 int32_t batch_dim;
9086 ReverseSequenceOptionsT()
9087 : seq_dim(0),
9088 batch_dim(0) {
9089 }
9090};
9091
9092struct ReverseSequenceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9093 typedef ReverseSequenceOptionsT NativeTableType;
9094 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9095 VT_SEQ_DIM = 4,
9096 VT_BATCH_DIM = 6
9097 };
9098 int32_t seq_dim() const {
9099 return GetField<int32_t>(VT_SEQ_DIM, 0);
9100 }
9101 int32_t batch_dim() const {
9102 return GetField<int32_t>(VT_BATCH_DIM, 0);
9103 }
9104 bool Verify(flatbuffers::Verifier &verifier) const {
9105 return VerifyTableStart(verifier) &&
9106 VerifyField<int32_t>(verifier, VT_SEQ_DIM) &&
9107 VerifyField<int32_t>(verifier, VT_BATCH_DIM) &&
9108 verifier.EndTable();
9109 }
9110 ReverseSequenceOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9111 void UnPackTo(ReverseSequenceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9112 static flatbuffers::Offset<ReverseSequenceOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9113};
9114
9115struct ReverseSequenceOptionsBuilder {
9116 flatbuffers::FlatBufferBuilder &fbb_;
9117 flatbuffers::uoffset_t start_;
9118 void add_seq_dim(int32_t seq_dim) {
9119 fbb_.AddElement<int32_t>(ReverseSequenceOptions::VT_SEQ_DIM, seq_dim, 0);
9120 }
9121 void add_batch_dim(int32_t batch_dim) {
9122 fbb_.AddElement<int32_t>(ReverseSequenceOptions::VT_BATCH_DIM, batch_dim, 0);
9123 }
9124 explicit ReverseSequenceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9125 : fbb_(_fbb) {
9126 start_ = fbb_.StartTable();
9127 }
9128 ReverseSequenceOptionsBuilder &operator=(const ReverseSequenceOptionsBuilder &);
9129 flatbuffers::Offset<ReverseSequenceOptions> Finish() {
9130 const auto end = fbb_.EndTable(start_);
9131 auto o = flatbuffers::Offset<ReverseSequenceOptions>(end);
9132 return o;
9133 }
9134};
9135
9136inline flatbuffers::Offset<ReverseSequenceOptions> CreateReverseSequenceOptions(
9137 flatbuffers::FlatBufferBuilder &_fbb,
9138 int32_t seq_dim = 0,
9139 int32_t batch_dim = 0) {
9140 ReverseSequenceOptionsBuilder builder_(_fbb);
9141 builder_.add_batch_dim(batch_dim);
9142 builder_.add_seq_dim(seq_dim);
9143 return builder_.Finish();
9144}
9145
9146flatbuffers::Offset<ReverseSequenceOptions> CreateReverseSequenceOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9147
9148struct MatrixDiagOptionsT : public flatbuffers::NativeTable {
9149 typedef MatrixDiagOptions TableType;
9150 MatrixDiagOptionsT() {
9151 }
9152};
9153
9154struct MatrixDiagOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9155 typedef MatrixDiagOptionsT NativeTableType;
9156 bool Verify(flatbuffers::Verifier &verifier) const {
9157 return VerifyTableStart(verifier) &&
9158 verifier.EndTable();
9159 }
9160 MatrixDiagOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9161 void UnPackTo(MatrixDiagOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9162 static flatbuffers::Offset<MatrixDiagOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatrixDiagOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9163};
9164
9165struct MatrixDiagOptionsBuilder {
9166 flatbuffers::FlatBufferBuilder &fbb_;
9167 flatbuffers::uoffset_t start_;
9168 explicit MatrixDiagOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9169 : fbb_(_fbb) {
9170 start_ = fbb_.StartTable();
9171 }
9172 MatrixDiagOptionsBuilder &operator=(const MatrixDiagOptionsBuilder &);
9173 flatbuffers::Offset<MatrixDiagOptions> Finish() {
9174 const auto end = fbb_.EndTable(start_);
9175 auto o = flatbuffers::Offset<MatrixDiagOptions>(end);
9176 return o;
9177 }
9178};
9179
9180inline flatbuffers::Offset<MatrixDiagOptions> CreateMatrixDiagOptions(
9181 flatbuffers::FlatBufferBuilder &_fbb) {
9182 MatrixDiagOptionsBuilder builder_(_fbb);
9183 return builder_.Finish();
9184}
9185
9186flatbuffers::Offset<MatrixDiagOptions> CreateMatrixDiagOptions(flatbuffers::FlatBufferBuilder &_fbb, const MatrixDiagOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9187
9188struct QuantizeOptionsT : public flatbuffers::NativeTable {
9189 typedef QuantizeOptions TableType;
9190 QuantizeOptionsT() {
9191 }
9192};
9193
9194struct QuantizeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9195 typedef QuantizeOptionsT NativeTableType;
9196 bool Verify(flatbuffers::Verifier &verifier) const {
9197 return VerifyTableStart(verifier) &&
9198 verifier.EndTable();
9199 }
9200 QuantizeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9201 void UnPackTo(QuantizeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9202 static flatbuffers::Offset<QuantizeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9203};
9204
9205struct QuantizeOptionsBuilder {
9206 flatbuffers::FlatBufferBuilder &fbb_;
9207 flatbuffers::uoffset_t start_;
9208 explicit QuantizeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9209 : fbb_(_fbb) {
9210 start_ = fbb_.StartTable();
9211 }
9212 QuantizeOptionsBuilder &operator=(const QuantizeOptionsBuilder &);
9213 flatbuffers::Offset<QuantizeOptions> Finish() {
9214 const auto end = fbb_.EndTable(start_);
9215 auto o = flatbuffers::Offset<QuantizeOptions>(end);
9216 return o;
9217 }
9218};
9219
9220inline flatbuffers::Offset<QuantizeOptions> CreateQuantizeOptions(
9221 flatbuffers::FlatBufferBuilder &_fbb) {
9222 QuantizeOptionsBuilder builder_(_fbb);
9223 return builder_.Finish();
9224}
9225
9226flatbuffers::Offset<QuantizeOptions> CreateQuantizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9227
9228struct MatrixSetDiagOptionsT : public flatbuffers::NativeTable {
9229 typedef MatrixSetDiagOptions TableType;
9230 MatrixSetDiagOptionsT() {
9231 }
9232};
9233
9234struct MatrixSetDiagOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9235 typedef MatrixSetDiagOptionsT NativeTableType;
9236 bool Verify(flatbuffers::Verifier &verifier) const {
9237 return VerifyTableStart(verifier) &&
9238 verifier.EndTable();
9239 }
9240 MatrixSetDiagOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9241 void UnPackTo(MatrixSetDiagOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9242 static flatbuffers::Offset<MatrixSetDiagOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatrixSetDiagOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9243};
9244
9245struct MatrixSetDiagOptionsBuilder {
9246 flatbuffers::FlatBufferBuilder &fbb_;
9247 flatbuffers::uoffset_t start_;
9248 explicit MatrixSetDiagOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9249 : fbb_(_fbb) {
9250 start_ = fbb_.StartTable();
9251 }
9252 MatrixSetDiagOptionsBuilder &operator=(const MatrixSetDiagOptionsBuilder &);
9253 flatbuffers::Offset<MatrixSetDiagOptions> Finish() {
9254 const auto end = fbb_.EndTable(start_);
9255 auto o = flatbuffers::Offset<MatrixSetDiagOptions>(end);
9256 return o;
9257 }
9258};
9259
9260inline flatbuffers::Offset<MatrixSetDiagOptions> CreateMatrixSetDiagOptions(
9261 flatbuffers::FlatBufferBuilder &_fbb) {
9262 MatrixSetDiagOptionsBuilder builder_(_fbb);
9263 return builder_.Finish();
9264}
9265
9266flatbuffers::Offset<MatrixSetDiagOptions> CreateMatrixSetDiagOptions(flatbuffers::FlatBufferBuilder &_fbb, const MatrixSetDiagOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9267
9268struct IfOptionsT : public flatbuffers::NativeTable {
9269 typedef IfOptions TableType;
9270 int32_t then_subgraph_index;
9271 int32_t else_subgraph_index;
9272 IfOptionsT()
9273 : then_subgraph_index(0),
9274 else_subgraph_index(0) {
9275 }
9276};
9277
9278struct IfOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9279 typedef IfOptionsT NativeTableType;
9280 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9281 VT_THEN_SUBGRAPH_INDEX = 4,
9282 VT_ELSE_SUBGRAPH_INDEX = 6
9283 };
9284 int32_t then_subgraph_index() const {
9285 return GetField<int32_t>(VT_THEN_SUBGRAPH_INDEX, 0);
9286 }
9287 int32_t else_subgraph_index() const {
9288 return GetField<int32_t>(VT_ELSE_SUBGRAPH_INDEX, 0);
9289 }
9290 bool Verify(flatbuffers::Verifier &verifier) const {
9291 return VerifyTableStart(verifier) &&
9292 VerifyField<int32_t>(verifier, VT_THEN_SUBGRAPH_INDEX) &&
9293 VerifyField<int32_t>(verifier, VT_ELSE_SUBGRAPH_INDEX) &&
9294 verifier.EndTable();
9295 }
9296 IfOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9297 void UnPackTo(IfOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9298 static flatbuffers::Offset<IfOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const IfOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9299};
9300
9301struct IfOptionsBuilder {
9302 flatbuffers::FlatBufferBuilder &fbb_;
9303 flatbuffers::uoffset_t start_;
9304 void add_then_subgraph_index(int32_t then_subgraph_index) {
9305 fbb_.AddElement<int32_t>(IfOptions::VT_THEN_SUBGRAPH_INDEX, then_subgraph_index, 0);
9306 }
9307 void add_else_subgraph_index(int32_t else_subgraph_index) {
9308 fbb_.AddElement<int32_t>(IfOptions::VT_ELSE_SUBGRAPH_INDEX, else_subgraph_index, 0);
9309 }
9310 explicit IfOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9311 : fbb_(_fbb) {
9312 start_ = fbb_.StartTable();
9313 }
9314 IfOptionsBuilder &operator=(const IfOptionsBuilder &);
9315 flatbuffers::Offset<IfOptions> Finish() {
9316 const auto end = fbb_.EndTable(start_);
9317 auto o = flatbuffers::Offset<IfOptions>(end);
9318 return o;
9319 }
9320};
9321
9322inline flatbuffers::Offset<IfOptions> CreateIfOptions(
9323 flatbuffers::FlatBufferBuilder &_fbb,
9324 int32_t then_subgraph_index = 0,
9325 int32_t else_subgraph_index = 0) {
9326 IfOptionsBuilder builder_(_fbb);
9327 builder_.add_else_subgraph_index(else_subgraph_index);
9328 builder_.add_then_subgraph_index(then_subgraph_index);
9329 return builder_.Finish();
9330}
9331
9332flatbuffers::Offset<IfOptions> CreateIfOptions(flatbuffers::FlatBufferBuilder &_fbb, const IfOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9333
9334struct CallOnceOptionsT : public flatbuffers::NativeTable {
9335 typedef CallOnceOptions TableType;
9336 int32_t init_subgraph_index;
9337 CallOnceOptionsT()
9338 : init_subgraph_index(0) {
9339 }
9340};
9341
9342struct CallOnceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9343 typedef CallOnceOptionsT NativeTableType;
9344 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9345 VT_INIT_SUBGRAPH_INDEX = 4
9346 };
9347 int32_t init_subgraph_index() const {
9348 return GetField<int32_t>(VT_INIT_SUBGRAPH_INDEX, 0);
9349 }
9350 bool Verify(flatbuffers::Verifier &verifier) const {
9351 return VerifyTableStart(verifier) &&
9352 VerifyField<int32_t>(verifier, VT_INIT_SUBGRAPH_INDEX) &&
9353 verifier.EndTable();
9354 }
9355 CallOnceOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9356 void UnPackTo(CallOnceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9357 static flatbuffers::Offset<CallOnceOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CallOnceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9358};
9359
9360struct CallOnceOptionsBuilder {
9361 flatbuffers::FlatBufferBuilder &fbb_;
9362 flatbuffers::uoffset_t start_;
9363 void add_init_subgraph_index(int32_t init_subgraph_index) {
9364 fbb_.AddElement<int32_t>(CallOnceOptions::VT_INIT_SUBGRAPH_INDEX, init_subgraph_index, 0);
9365 }
9366 explicit CallOnceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9367 : fbb_(_fbb) {
9368 start_ = fbb_.StartTable();
9369 }
9370 CallOnceOptionsBuilder &operator=(const CallOnceOptionsBuilder &);
9371 flatbuffers::Offset<CallOnceOptions> Finish() {
9372 const auto end = fbb_.EndTable(start_);
9373 auto o = flatbuffers::Offset<CallOnceOptions>(end);
9374 return o;
9375 }
9376};
9377
9378inline flatbuffers::Offset<CallOnceOptions> CreateCallOnceOptions(
9379 flatbuffers::FlatBufferBuilder &_fbb,
9380 int32_t init_subgraph_index = 0) {
9381 CallOnceOptionsBuilder builder_(_fbb);
9382 builder_.add_init_subgraph_index(init_subgraph_index);
9383 return builder_.Finish();
9384}
9385
9386flatbuffers::Offset<CallOnceOptions> CreateCallOnceOptions(flatbuffers::FlatBufferBuilder &_fbb, const CallOnceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9387
9388struct WhileOptionsT : public flatbuffers::NativeTable {
9389 typedef WhileOptions TableType;
9390 int32_t cond_subgraph_index;
9391 int32_t body_subgraph_index;
9392 WhileOptionsT()
9393 : cond_subgraph_index(0),
9394 body_subgraph_index(0) {
9395 }
9396};
9397
9398struct WhileOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9399 typedef WhileOptionsT NativeTableType;
9400 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9401 VT_COND_SUBGRAPH_INDEX = 4,
9402 VT_BODY_SUBGRAPH_INDEX = 6
9403 };
9404 int32_t cond_subgraph_index() const {
9405 return GetField<int32_t>(VT_COND_SUBGRAPH_INDEX, 0);
9406 }
9407 int32_t body_subgraph_index() const {
9408 return GetField<int32_t>(VT_BODY_SUBGRAPH_INDEX, 0);
9409 }
9410 bool Verify(flatbuffers::Verifier &verifier) const {
9411 return VerifyTableStart(verifier) &&
9412 VerifyField<int32_t>(verifier, VT_COND_SUBGRAPH_INDEX) &&
9413 VerifyField<int32_t>(verifier, VT_BODY_SUBGRAPH_INDEX) &&
9414 verifier.EndTable();
9415 }
9416 WhileOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9417 void UnPackTo(WhileOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9418 static flatbuffers::Offset<WhileOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const WhileOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9419};
9420
9421struct WhileOptionsBuilder {
9422 flatbuffers::FlatBufferBuilder &fbb_;
9423 flatbuffers::uoffset_t start_;
9424 void add_cond_subgraph_index(int32_t cond_subgraph_index) {
9425 fbb_.AddElement<int32_t>(WhileOptions::VT_COND_SUBGRAPH_INDEX, cond_subgraph_index, 0);
9426 }
9427 void add_body_subgraph_index(int32_t body_subgraph_index) {
9428 fbb_.AddElement<int32_t>(WhileOptions::VT_BODY_SUBGRAPH_INDEX, body_subgraph_index, 0);
9429 }
9430 explicit WhileOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9431 : fbb_(_fbb) {
9432 start_ = fbb_.StartTable();
9433 }
9434 WhileOptionsBuilder &operator=(const WhileOptionsBuilder &);
9435 flatbuffers::Offset<WhileOptions> Finish() {
9436 const auto end = fbb_.EndTable(start_);
9437 auto o = flatbuffers::Offset<WhileOptions>(end);
9438 return o;
9439 }
9440};
9441
9442inline flatbuffers::Offset<WhileOptions> CreateWhileOptions(
9443 flatbuffers::FlatBufferBuilder &_fbb,
9444 int32_t cond_subgraph_index = 0,
9445 int32_t body_subgraph_index = 0) {
9446 WhileOptionsBuilder builder_(_fbb);
9447 builder_.add_body_subgraph_index(body_subgraph_index);
9448 builder_.add_cond_subgraph_index(cond_subgraph_index);
9449 return builder_.Finish();
9450}
9451
9452flatbuffers::Offset<WhileOptions> CreateWhileOptions(flatbuffers::FlatBufferBuilder &_fbb, const WhileOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9453
9454struct NonMaxSuppressionV4OptionsT : public flatbuffers::NativeTable {
9455 typedef NonMaxSuppressionV4Options TableType;
9456 NonMaxSuppressionV4OptionsT() {
9457 }
9458};
9459
9460struct NonMaxSuppressionV4Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9461 typedef NonMaxSuppressionV4OptionsT NativeTableType;
9462 bool Verify(flatbuffers::Verifier &verifier) const {
9463 return VerifyTableStart(verifier) &&
9464 verifier.EndTable();
9465 }
9466 NonMaxSuppressionV4OptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9467 void UnPackTo(NonMaxSuppressionV4OptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9468 static flatbuffers::Offset<NonMaxSuppressionV4Options> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV4OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9469};
9470
9471struct NonMaxSuppressionV4OptionsBuilder {
9472 flatbuffers::FlatBufferBuilder &fbb_;
9473 flatbuffers::uoffset_t start_;
9474 explicit NonMaxSuppressionV4OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9475 : fbb_(_fbb) {
9476 start_ = fbb_.StartTable();
9477 }
9478 NonMaxSuppressionV4OptionsBuilder &operator=(const NonMaxSuppressionV4OptionsBuilder &);
9479 flatbuffers::Offset<NonMaxSuppressionV4Options> Finish() {
9480 const auto end = fbb_.EndTable(start_);
9481 auto o = flatbuffers::Offset<NonMaxSuppressionV4Options>(end);
9482 return o;
9483 }
9484};
9485
9486inline flatbuffers::Offset<NonMaxSuppressionV4Options> CreateNonMaxSuppressionV4Options(
9487 flatbuffers::FlatBufferBuilder &_fbb) {
9488 NonMaxSuppressionV4OptionsBuilder builder_(_fbb);
9489 return builder_.Finish();
9490}
9491
9492flatbuffers::Offset<NonMaxSuppressionV4Options> CreateNonMaxSuppressionV4Options(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV4OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9493
9494struct NonMaxSuppressionV5OptionsT : public flatbuffers::NativeTable {
9495 typedef NonMaxSuppressionV5Options TableType;
9496 NonMaxSuppressionV5OptionsT() {
9497 }
9498};
9499
9500struct NonMaxSuppressionV5Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9501 typedef NonMaxSuppressionV5OptionsT NativeTableType;
9502 bool Verify(flatbuffers::Verifier &verifier) const {
9503 return VerifyTableStart(verifier) &&
9504 verifier.EndTable();
9505 }
9506 NonMaxSuppressionV5OptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9507 void UnPackTo(NonMaxSuppressionV5OptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9508 static flatbuffers::Offset<NonMaxSuppressionV5Options> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV5OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9509};
9510
9511struct NonMaxSuppressionV5OptionsBuilder {
9512 flatbuffers::FlatBufferBuilder &fbb_;
9513 flatbuffers::uoffset_t start_;
9514 explicit NonMaxSuppressionV5OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9515 : fbb_(_fbb) {
9516 start_ = fbb_.StartTable();
9517 }
9518 NonMaxSuppressionV5OptionsBuilder &operator=(const NonMaxSuppressionV5OptionsBuilder &);
9519 flatbuffers::Offset<NonMaxSuppressionV5Options> Finish() {
9520 const auto end = fbb_.EndTable(start_);
9521 auto o = flatbuffers::Offset<NonMaxSuppressionV5Options>(end);
9522 return o;
9523 }
9524};
9525
9526inline flatbuffers::Offset<NonMaxSuppressionV5Options> CreateNonMaxSuppressionV5Options(
9527 flatbuffers::FlatBufferBuilder &_fbb) {
9528 NonMaxSuppressionV5OptionsBuilder builder_(_fbb);
9529 return builder_.Finish();
9530}
9531
9532flatbuffers::Offset<NonMaxSuppressionV5Options> CreateNonMaxSuppressionV5Options(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV5OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9533
9534struct ScatterNdOptionsT : public flatbuffers::NativeTable {
9535 typedef ScatterNdOptions TableType;
9536 ScatterNdOptionsT() {
9537 }
9538};
9539
9540struct ScatterNdOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9541 typedef ScatterNdOptionsT NativeTableType;
9542 bool Verify(flatbuffers::Verifier &verifier) const {
9543 return VerifyTableStart(verifier) &&
9544 verifier.EndTable();
9545 }
9546 ScatterNdOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9547 void UnPackTo(ScatterNdOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9548 static flatbuffers::Offset<ScatterNdOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ScatterNdOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9549};
9550
9551struct ScatterNdOptionsBuilder {
9552 flatbuffers::FlatBufferBuilder &fbb_;
9553 flatbuffers::uoffset_t start_;
9554 explicit ScatterNdOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9555 : fbb_(_fbb) {
9556 start_ = fbb_.StartTable();
9557 }
9558 ScatterNdOptionsBuilder &operator=(const ScatterNdOptionsBuilder &);
9559 flatbuffers::Offset<ScatterNdOptions> Finish() {
9560 const auto end = fbb_.EndTable(start_);
9561 auto o = flatbuffers::Offset<ScatterNdOptions>(end);
9562 return o;
9563 }
9564};
9565
9566inline flatbuffers::Offset<ScatterNdOptions> CreateScatterNdOptions(
9567 flatbuffers::FlatBufferBuilder &_fbb) {
9568 ScatterNdOptionsBuilder builder_(_fbb);
9569 return builder_.Finish();
9570}
9571
9572flatbuffers::Offset<ScatterNdOptions> CreateScatterNdOptions(flatbuffers::FlatBufferBuilder &_fbb, const ScatterNdOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9573
9574struct SelectV2OptionsT : public flatbuffers::NativeTable {
9575 typedef SelectV2Options TableType;
9576 SelectV2OptionsT() {
9577 }
9578};
9579
9580struct SelectV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9581 typedef SelectV2OptionsT NativeTableType;
9582 bool Verify(flatbuffers::Verifier &verifier) const {
9583 return VerifyTableStart(verifier) &&
9584 verifier.EndTable();
9585 }
9586 SelectV2OptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9587 void UnPackTo(SelectV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9588 static flatbuffers::Offset<SelectV2Options> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelectV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9589};
9590
9591struct SelectV2OptionsBuilder {
9592 flatbuffers::FlatBufferBuilder &fbb_;
9593 flatbuffers::uoffset_t start_;
9594 explicit SelectV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9595 : fbb_(_fbb) {
9596 start_ = fbb_.StartTable();
9597 }
9598 SelectV2OptionsBuilder &operator=(const SelectV2OptionsBuilder &);
9599 flatbuffers::Offset<SelectV2Options> Finish() {
9600 const auto end = fbb_.EndTable(start_);
9601 auto o = flatbuffers::Offset<SelectV2Options>(end);
9602 return o;
9603 }
9604};
9605
9606inline flatbuffers::Offset<SelectV2Options> CreateSelectV2Options(
9607 flatbuffers::FlatBufferBuilder &_fbb) {
9608 SelectV2OptionsBuilder builder_(_fbb);
9609 return builder_.Finish();
9610}
9611
9612flatbuffers::Offset<SelectV2Options> CreateSelectV2Options(flatbuffers::FlatBufferBuilder &_fbb, const SelectV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9613
9614struct DensifyOptionsT : public flatbuffers::NativeTable {
9615 typedef DensifyOptions TableType;
9616 DensifyOptionsT() {
9617 }
9618};
9619
9620struct DensifyOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9621 typedef DensifyOptionsT NativeTableType;
9622 bool Verify(flatbuffers::Verifier &verifier) const {
9623 return VerifyTableStart(verifier) &&
9624 verifier.EndTable();
9625 }
9626 DensifyOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9627 void UnPackTo(DensifyOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9628 static flatbuffers::Offset<DensifyOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DensifyOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9629};
9630
9631struct DensifyOptionsBuilder {
9632 flatbuffers::FlatBufferBuilder &fbb_;
9633 flatbuffers::uoffset_t start_;
9634 explicit DensifyOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9635 : fbb_(_fbb) {
9636 start_ = fbb_.StartTable();
9637 }
9638 DensifyOptionsBuilder &operator=(const DensifyOptionsBuilder &);
9639 flatbuffers::Offset<DensifyOptions> Finish() {
9640 const auto end = fbb_.EndTable(start_);
9641 auto o = flatbuffers::Offset<DensifyOptions>(end);
9642 return o;
9643 }
9644};
9645
9646inline flatbuffers::Offset<DensifyOptions> CreateDensifyOptions(
9647 flatbuffers::FlatBufferBuilder &_fbb) {
9648 DensifyOptionsBuilder builder_(_fbb);
9649 return builder_.Finish();
9650}
9651
9652flatbuffers::Offset<DensifyOptions> CreateDensifyOptions(flatbuffers::FlatBufferBuilder &_fbb, const DensifyOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9653
9654struct SegmentSumOptionsT : public flatbuffers::NativeTable {
9655 typedef SegmentSumOptions TableType;
9656 SegmentSumOptionsT() {
9657 }
9658};
9659
9660struct SegmentSumOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9661 typedef SegmentSumOptionsT NativeTableType;
9662 bool Verify(flatbuffers::Verifier &verifier) const {
9663 return VerifyTableStart(verifier) &&
9664 verifier.EndTable();
9665 }
9666 SegmentSumOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9667 void UnPackTo(SegmentSumOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9668 static flatbuffers::Offset<SegmentSumOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SegmentSumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9669};
9670
9671struct SegmentSumOptionsBuilder {
9672 flatbuffers::FlatBufferBuilder &fbb_;
9673 flatbuffers::uoffset_t start_;
9674 explicit SegmentSumOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9675 : fbb_(_fbb) {
9676 start_ = fbb_.StartTable();
9677 }
9678 SegmentSumOptionsBuilder &operator=(const SegmentSumOptionsBuilder &);
9679 flatbuffers::Offset<SegmentSumOptions> Finish() {
9680 const auto end = fbb_.EndTable(start_);
9681 auto o = flatbuffers::Offset<SegmentSumOptions>(end);
9682 return o;
9683 }
9684};
9685
9686inline flatbuffers::Offset<SegmentSumOptions> CreateSegmentSumOptions(
9687 flatbuffers::FlatBufferBuilder &_fbb) {
9688 SegmentSumOptionsBuilder builder_(_fbb);
9689 return builder_.Finish();
9690}
9691
9692flatbuffers::Offset<SegmentSumOptions> CreateSegmentSumOptions(flatbuffers::FlatBufferBuilder &_fbb, const SegmentSumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9693
9694struct BatchMatMulOptionsT : public flatbuffers::NativeTable {
9695 typedef BatchMatMulOptions TableType;
9696 bool adj_x;
9697 bool adj_y;
9698 bool asymmetric_quantize_inputs;
9699 BatchMatMulOptionsT()
9700 : adj_x(false),
9701 adj_y(false),
9702 asymmetric_quantize_inputs(false) {
9703 }
9704};
9705
9706struct BatchMatMulOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9707 typedef BatchMatMulOptionsT NativeTableType;
9708 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9709 VT_ADJ_X = 4,
9710 VT_ADJ_Y = 6,
9711 VT_ASYMMETRIC_QUANTIZE_INPUTS = 8
9712 };
9713 bool adj_x() const {
9714 return GetField<uint8_t>(VT_ADJ_X, 0) != 0;
9715 }
9716 bool adj_y() const {
9717 return GetField<uint8_t>(VT_ADJ_Y, 0) != 0;
9718 }
9719 bool asymmetric_quantize_inputs() const {
9720 return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
9721 }
9722 bool Verify(flatbuffers::Verifier &verifier) const {
9723 return VerifyTableStart(verifier) &&
9724 VerifyField<uint8_t>(verifier, VT_ADJ_X) &&
9725 VerifyField<uint8_t>(verifier, VT_ADJ_Y) &&
9726 VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) &&
9727 verifier.EndTable();
9728 }
9729 BatchMatMulOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9730 void UnPackTo(BatchMatMulOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9731 static flatbuffers::Offset<BatchMatMulOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BatchMatMulOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9732};
9733
9734struct BatchMatMulOptionsBuilder {
9735 flatbuffers::FlatBufferBuilder &fbb_;
9736 flatbuffers::uoffset_t start_;
9737 void add_adj_x(bool adj_x) {
9738 fbb_.AddElement<uint8_t>(BatchMatMulOptions::VT_ADJ_X, static_cast<uint8_t>(adj_x), 0);
9739 }
9740 void add_adj_y(bool adj_y) {
9741 fbb_.AddElement<uint8_t>(BatchMatMulOptions::VT_ADJ_Y, static_cast<uint8_t>(adj_y), 0);
9742 }
9743 void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
9744 fbb_.AddElement<uint8_t>(BatchMatMulOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
9745 }
9746 explicit BatchMatMulOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9747 : fbb_(_fbb) {
9748 start_ = fbb_.StartTable();
9749 }
9750 BatchMatMulOptionsBuilder &operator=(const BatchMatMulOptionsBuilder &);
9751 flatbuffers::Offset<BatchMatMulOptions> Finish() {
9752 const auto end = fbb_.EndTable(start_);
9753 auto o = flatbuffers::Offset<BatchMatMulOptions>(end);
9754 return o;
9755 }
9756};
9757
9758inline flatbuffers::Offset<BatchMatMulOptions> CreateBatchMatMulOptions(
9759 flatbuffers::FlatBufferBuilder &_fbb,
9760 bool adj_x = false,
9761 bool adj_y = false,
9762 bool asymmetric_quantize_inputs = false) {
9763 BatchMatMulOptionsBuilder builder_(_fbb);
9764 builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
9765 builder_.add_adj_y(adj_y);
9766 builder_.add_adj_x(adj_x);
9767 return builder_.Finish();
9768}
9769
9770flatbuffers::Offset<BatchMatMulOptions> CreateBatchMatMulOptions(flatbuffers::FlatBufferBuilder &_fbb, const BatchMatMulOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9771
9772struct CumsumOptionsT : public flatbuffers::NativeTable {
9773 typedef CumsumOptions TableType;
9774 bool exclusive;
9775 bool reverse;
9776 CumsumOptionsT()
9777 : exclusive(false),
9778 reverse(false) {
9779 }
9780};
9781
9782struct CumsumOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9783 typedef CumsumOptionsT NativeTableType;
9784 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9785 VT_EXCLUSIVE = 4,
9786 VT_REVERSE = 6
9787 };
9788 bool exclusive() const {
9789 return GetField<uint8_t>(VT_EXCLUSIVE, 0) != 0;
9790 }
9791 bool reverse() const {
9792 return GetField<uint8_t>(VT_REVERSE, 0) != 0;
9793 }
9794 bool Verify(flatbuffers::Verifier &verifier) const {
9795 return VerifyTableStart(verifier) &&
9796 VerifyField<uint8_t>(verifier, VT_EXCLUSIVE) &&
9797 VerifyField<uint8_t>(verifier, VT_REVERSE) &&
9798 verifier.EndTable();
9799 }
9800 CumsumOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9801 void UnPackTo(CumsumOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9802 static flatbuffers::Offset<CumsumOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CumsumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9803};
9804
9805struct CumsumOptionsBuilder {
9806 flatbuffers::FlatBufferBuilder &fbb_;
9807 flatbuffers::uoffset_t start_;
9808 void add_exclusive(bool exclusive) {
9809 fbb_.AddElement<uint8_t>(CumsumOptions::VT_EXCLUSIVE, static_cast<uint8_t>(exclusive), 0);
9810 }
9811 void add_reverse(bool reverse) {
9812 fbb_.AddElement<uint8_t>(CumsumOptions::VT_REVERSE, static_cast<uint8_t>(reverse), 0);
9813 }
9814 explicit CumsumOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9815 : fbb_(_fbb) {
9816 start_ = fbb_.StartTable();
9817 }
9818 CumsumOptionsBuilder &operator=(const CumsumOptionsBuilder &);
9819 flatbuffers::Offset<CumsumOptions> Finish() {
9820 const auto end = fbb_.EndTable(start_);
9821 auto o = flatbuffers::Offset<CumsumOptions>(end);
9822 return o;
9823 }
9824};
9825
9826inline flatbuffers::Offset<CumsumOptions> CreateCumsumOptions(
9827 flatbuffers::FlatBufferBuilder &_fbb,
9828 bool exclusive = false,
9829 bool reverse = false) {
9830 CumsumOptionsBuilder builder_(_fbb);
9831 builder_.add_reverse(reverse);
9832 builder_.add_exclusive(exclusive);
9833 return builder_.Finish();
9834}
9835
9836flatbuffers::Offset<CumsumOptions> CreateCumsumOptions(flatbuffers::FlatBufferBuilder &_fbb, const CumsumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9837
9838struct BroadcastToOptionsT : public flatbuffers::NativeTable {
9839 typedef BroadcastToOptions TableType;
9840 BroadcastToOptionsT() {
9841 }
9842};
9843
9844struct BroadcastToOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9845 typedef BroadcastToOptionsT NativeTableType;
9846 bool Verify(flatbuffers::Verifier &verifier) const {
9847 return VerifyTableStart(verifier) &&
9848 verifier.EndTable();
9849 }
9850 BroadcastToOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9851 void UnPackTo(BroadcastToOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9852 static flatbuffers::Offset<BroadcastToOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BroadcastToOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9853};
9854
9855struct BroadcastToOptionsBuilder {
9856 flatbuffers::FlatBufferBuilder &fbb_;
9857 flatbuffers::uoffset_t start_;
9858 explicit BroadcastToOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9859 : fbb_(_fbb) {
9860 start_ = fbb_.StartTable();
9861 }
9862 BroadcastToOptionsBuilder &operator=(const BroadcastToOptionsBuilder &);
9863 flatbuffers::Offset<BroadcastToOptions> Finish() {
9864 const auto end = fbb_.EndTable(start_);
9865 auto o = flatbuffers::Offset<BroadcastToOptions>(end);
9866 return o;
9867 }
9868};
9869
9870inline flatbuffers::Offset<BroadcastToOptions> CreateBroadcastToOptions(
9871 flatbuffers::FlatBufferBuilder &_fbb) {
9872 BroadcastToOptionsBuilder builder_(_fbb);
9873 return builder_.Finish();
9874}
9875
9876flatbuffers::Offset<BroadcastToOptions> CreateBroadcastToOptions(flatbuffers::FlatBufferBuilder &_fbb, const BroadcastToOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9877
9878struct Rfft2dOptionsT : public flatbuffers::NativeTable {
9879 typedef Rfft2dOptions TableType;
9880 Rfft2dOptionsT() {
9881 }
9882};
9883
9884struct Rfft2dOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9885 typedef Rfft2dOptionsT NativeTableType;
9886 bool Verify(flatbuffers::Verifier &verifier) const {
9887 return VerifyTableStart(verifier) &&
9888 verifier.EndTable();
9889 }
9890 Rfft2dOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9891 void UnPackTo(Rfft2dOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9892 static flatbuffers::Offset<Rfft2dOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const Rfft2dOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9893};
9894
9895struct Rfft2dOptionsBuilder {
9896 flatbuffers::FlatBufferBuilder &fbb_;
9897 flatbuffers::uoffset_t start_;
9898 explicit Rfft2dOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9899 : fbb_(_fbb) {
9900 start_ = fbb_.StartTable();
9901 }
9902 Rfft2dOptionsBuilder &operator=(const Rfft2dOptionsBuilder &);
9903 flatbuffers::Offset<Rfft2dOptions> Finish() {
9904 const auto end = fbb_.EndTable(start_);
9905 auto o = flatbuffers::Offset<Rfft2dOptions>(end);
9906 return o;
9907 }
9908};
9909
9910inline flatbuffers::Offset<Rfft2dOptions> CreateRfft2dOptions(
9911 flatbuffers::FlatBufferBuilder &_fbb) {
9912 Rfft2dOptionsBuilder builder_(_fbb);
9913 return builder_.Finish();
9914}
9915
9916flatbuffers::Offset<Rfft2dOptions> CreateRfft2dOptions(flatbuffers::FlatBufferBuilder &_fbb, const Rfft2dOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9917
9918struct HashtableOptionsT : public flatbuffers::NativeTable {
9919 typedef HashtableOptions TableType;
9920 int32_t table_id;
9921 tflite::TensorType key_dtype;
9922 tflite::TensorType value_dtype;
9923 HashtableOptionsT()
9924 : table_id(0),
9925 key_dtype(tflite::TensorType_FLOAT32),
9926 value_dtype(tflite::TensorType_FLOAT32) {
9927 }
9928};
9929
9930struct HashtableOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9931 typedef HashtableOptionsT NativeTableType;
9932 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9933 VT_TABLE_ID = 4,
9934 VT_KEY_DTYPE = 6,
9935 VT_VALUE_DTYPE = 8
9936 };
9937 int32_t table_id() const {
9938 return GetField<int32_t>(VT_TABLE_ID, 0);
9939 }
9940 tflite::TensorType key_dtype() const {
9941 return static_cast<tflite::TensorType>(GetField<int8_t>(VT_KEY_DTYPE, 0));
9942 }
9943 tflite::TensorType value_dtype() const {
9944 return static_cast<tflite::TensorType>(GetField<int8_t>(VT_VALUE_DTYPE, 0));
9945 }
9946 bool Verify(flatbuffers::Verifier &verifier) const {
9947 return VerifyTableStart(verifier) &&
9948 VerifyField<int32_t>(verifier, VT_TABLE_ID) &&
9949 VerifyField<int8_t>(verifier, VT_KEY_DTYPE) &&
9950 VerifyField<int8_t>(verifier, VT_VALUE_DTYPE) &&
9951 verifier.EndTable();
9952 }
9953 HashtableOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9954 void UnPackTo(HashtableOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9955 static flatbuffers::Offset<HashtableOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9956};
9957
9958struct HashtableOptionsBuilder {
9959 flatbuffers::FlatBufferBuilder &fbb_;
9960 flatbuffers::uoffset_t start_;
9961 void add_table_id(int32_t table_id) {
9962 fbb_.AddElement<int32_t>(HashtableOptions::VT_TABLE_ID, table_id, 0);
9963 }
9964 void add_key_dtype(tflite::TensorType key_dtype) {
9965 fbb_.AddElement<int8_t>(HashtableOptions::VT_KEY_DTYPE, static_cast<int8_t>(key_dtype), 0);
9966 }
9967 void add_value_dtype(tflite::TensorType value_dtype) {
9968 fbb_.AddElement<int8_t>(HashtableOptions::VT_VALUE_DTYPE, static_cast<int8_t>(value_dtype), 0);
9969 }
9970 explicit HashtableOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9971 : fbb_(_fbb) {
9972 start_ = fbb_.StartTable();
9973 }
9974 HashtableOptionsBuilder &operator=(const HashtableOptionsBuilder &);
9975 flatbuffers::Offset<HashtableOptions> Finish() {
9976 const auto end = fbb_.EndTable(start_);
9977 auto o = flatbuffers::Offset<HashtableOptions>(end);
9978 return o;
9979 }
9980};
9981
9982inline flatbuffers::Offset<HashtableOptions> CreateHashtableOptions(
9983 flatbuffers::FlatBufferBuilder &_fbb,
9984 int32_t table_id = 0,
9985 tflite::TensorType key_dtype = tflite::TensorType_FLOAT32,
9986 tflite::TensorType value_dtype = tflite::TensorType_FLOAT32) {
9987 HashtableOptionsBuilder builder_(_fbb);
9988 builder_.add_table_id(table_id);
9989 builder_.add_value_dtype(value_dtype);
9990 builder_.add_key_dtype(key_dtype);
9991 return builder_.Finish();
9992}
9993
9994flatbuffers::Offset<HashtableOptions> CreateHashtableOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9995
9996struct HashtableFindOptionsT : public flatbuffers::NativeTable {
9997 typedef HashtableFindOptions TableType;
9998 HashtableFindOptionsT() {
9999 }
10000};
10001
10002struct HashtableFindOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10003 typedef HashtableFindOptionsT NativeTableType;
10004 bool Verify(flatbuffers::Verifier &verifier) const {
10005 return VerifyTableStart(verifier) &&
10006 verifier.EndTable();
10007 }
10008 HashtableFindOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10009 void UnPackTo(HashtableFindOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10010 static flatbuffers::Offset<HashtableFindOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableFindOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10011};
10012
10013struct HashtableFindOptionsBuilder {
10014 flatbuffers::FlatBufferBuilder &fbb_;
10015 flatbuffers::uoffset_t start_;
10016 explicit HashtableFindOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
10017 : fbb_(_fbb) {
10018 start_ = fbb_.StartTable();
10019 }
10020 HashtableFindOptionsBuilder &operator=(const HashtableFindOptionsBuilder &);
10021 flatbuffers::Offset<HashtableFindOptions> Finish() {
10022 const auto end = fbb_.EndTable(start_);
10023 auto o = flatbuffers::Offset<HashtableFindOptions>(end);
10024 return o;
10025 }
10026};
10027
10028inline flatbuffers::Offset<HashtableFindOptions> CreateHashtableFindOptions(
10029 flatbuffers::FlatBufferBuilder &_fbb) {
10030 HashtableFindOptionsBuilder builder_(_fbb);
10031 return builder_.Finish();
10032}
10033
10034flatbuffers::Offset<HashtableFindOptions> CreateHashtableFindOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableFindOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10035
10036struct HashtableImportOptionsT : public flatbuffers::NativeTable {
10037 typedef HashtableImportOptions TableType;
10038 HashtableImportOptionsT() {
10039 }
10040};
10041
10042struct HashtableImportOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10043 typedef HashtableImportOptionsT NativeTableType;
10044 bool Verify(flatbuffers::Verifier &verifier) const {
10045 return VerifyTableStart(verifier) &&
10046 verifier.EndTable();
10047 }
10048 HashtableImportOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10049 void UnPackTo(HashtableImportOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10050 static flatbuffers::Offset<HashtableImportOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableImportOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10051};
10052
10053struct HashtableImportOptionsBuilder {
10054 flatbuffers::FlatBufferBuilder &fbb_;
10055 flatbuffers::uoffset_t start_;
10056 explicit HashtableImportOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
10057 : fbb_(_fbb) {
10058 start_ = fbb_.StartTable();
10059 }
10060 HashtableImportOptionsBuilder &operator=(const HashtableImportOptionsBuilder &);
10061 flatbuffers::Offset<HashtableImportOptions> Finish() {
10062 const auto end = fbb_.EndTable(start_);
10063 auto o = flatbuffers::Offset<HashtableImportOptions>(end);
10064 return o;
10065 }
10066};
10067
10068inline flatbuffers::Offset<HashtableImportOptions> CreateHashtableImportOptions(
10069 flatbuffers::FlatBufferBuilder &_fbb) {
10070 HashtableImportOptionsBuilder builder_(_fbb);
10071 return builder_.Finish();
10072}
10073
10074flatbuffers::Offset<HashtableImportOptions> CreateHashtableImportOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableImportOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10075
10076struct HashtableSizeOptionsT : public flatbuffers::NativeTable {
10077 typedef HashtableSizeOptions TableType;
10078 HashtableSizeOptionsT() {
10079 }
10080};
10081
10082struct HashtableSizeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10083 typedef HashtableSizeOptionsT NativeTableType;
10084 bool Verify(flatbuffers::Verifier &verifier) const {
10085 return VerifyTableStart(verifier) &&
10086 verifier.EndTable();
10087 }
10088 HashtableSizeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10089 void UnPackTo(HashtableSizeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10090 static flatbuffers::Offset<HashtableSizeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableSizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10091};
10092
10093struct HashtableSizeOptionsBuilder {
10094 flatbuffers::FlatBufferBuilder &fbb_;
10095 flatbuffers::uoffset_t start_;
10096 explicit HashtableSizeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
10097 : fbb_(_fbb) {
10098 start_ = fbb_.StartTable();
10099 }
10100 HashtableSizeOptionsBuilder &operator=(const HashtableSizeOptionsBuilder &);
10101 flatbuffers::Offset<HashtableSizeOptions> Finish() {
10102 const auto end = fbb_.EndTable(start_);
10103 auto o = flatbuffers::Offset<HashtableSizeOptions>(end);
10104 return o;
10105 }
10106};
10107
10108inline flatbuffers::Offset<HashtableSizeOptions> CreateHashtableSizeOptions(
10109 flatbuffers::FlatBufferBuilder &_fbb) {
10110 HashtableSizeOptionsBuilder builder_(_fbb);
10111 return builder_.Finish();
10112}
10113
10114flatbuffers::Offset<HashtableSizeOptions> CreateHashtableSizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableSizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10115
10116struct OperatorCodeT : public flatbuffers::NativeTable {
10117 typedef OperatorCode TableType;
10118 int8_t deprecated_builtin_code;
10119 std::string custom_code;
10120 int32_t version;
10121 tflite::BuiltinOperator builtin_code;
10122 OperatorCodeT()
10123 : deprecated_builtin_code(0),
10124 version(1),
10125 builtin_code(tflite::BuiltinOperator_ADD) {
10126 }
10127};
10128
10129struct OperatorCode FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10130 typedef OperatorCodeT NativeTableType;
10131 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10132 VT_DEPRECATED_BUILTIN_CODE = 4,
10133 VT_CUSTOM_CODE = 6,
10134 VT_VERSION = 8,
10135 VT_BUILTIN_CODE = 10
10136 };
10137 int8_t deprecated_builtin_code() const {
10138 return GetField<int8_t>(VT_DEPRECATED_BUILTIN_CODE, 0);
10139 }
10140 const flatbuffers::String *custom_code() const {
10141 return GetPointer<const flatbuffers::String *>(VT_CUSTOM_CODE);
10142 }
10143 int32_t version() const {
10144 return GetField<int32_t>(VT_VERSION, 1);
10145 }
10146 tflite::BuiltinOperator builtin_code() const {
10147 return static_cast<tflite::BuiltinOperator>(GetField<int32_t>(VT_BUILTIN_CODE, 0));
10148 }
10149 bool Verify(flatbuffers::Verifier &verifier) const {
10150 return VerifyTableStart(verifier) &&
10151 VerifyField<int8_t>(verifier, VT_DEPRECATED_BUILTIN_CODE) &&
10152 VerifyOffset(verifier, VT_CUSTOM_CODE) &&
10153 verifier.VerifyString(custom_code()) &&
10154 VerifyField<int32_t>(verifier, VT_VERSION) &&
10155 VerifyField<int32_t>(verifier, VT_BUILTIN_CODE) &&
10156 verifier.EndTable();
10157 }
10158 OperatorCodeT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10159 void UnPackTo(OperatorCodeT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10160 static flatbuffers::Offset<OperatorCode> Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10161};
10162
10163struct OperatorCodeBuilder {
10164 flatbuffers::FlatBufferBuilder &fbb_;
10165 flatbuffers::uoffset_t start_;
10166 void add_deprecated_builtin_code(int8_t deprecated_builtin_code) {
10167 fbb_.AddElement<int8_t>(OperatorCode::VT_DEPRECATED_BUILTIN_CODE, deprecated_builtin_code, 0);
10168 }
10169 void add_custom_code(flatbuffers::Offset<flatbuffers::String> custom_code) {
10170 fbb_.AddOffset(OperatorCode::VT_CUSTOM_CODE, custom_code);
10171 }
10172 void add_version(int32_t version) {
10173 fbb_.AddElement<int32_t>(OperatorCode::VT_VERSION, version, 1);
10174 }
10175 void add_builtin_code(tflite::BuiltinOperator builtin_code) {
10176 fbb_.AddElement<int32_t>(OperatorCode::VT_BUILTIN_CODE, static_cast<int32_t>(builtin_code), 0);
10177 }
10178 explicit OperatorCodeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
10179 : fbb_(_fbb) {
10180 start_ = fbb_.StartTable();
10181 }
10182 OperatorCodeBuilder &operator=(const OperatorCodeBuilder &);
10183 flatbuffers::Offset<OperatorCode> Finish() {
10184 const auto end = fbb_.EndTable(start_);
10185 auto o = flatbuffers::Offset<OperatorCode>(end);
10186 return o;
10187 }
10188};
10189
10190inline flatbuffers::Offset<OperatorCode> CreateOperatorCode(
10191 flatbuffers::FlatBufferBuilder &_fbb,
10192 int8_t deprecated_builtin_code = 0,
10193 flatbuffers::Offset<flatbuffers::String> custom_code = 0,
10194 int32_t version = 1,
10195 tflite::BuiltinOperator builtin_code = tflite::BuiltinOperator_ADD) {
10196 OperatorCodeBuilder builder_(_fbb);
10197 builder_.add_builtin_code(builtin_code);
10198 builder_.add_version(version);
10199 builder_.add_custom_code(custom_code);
10200 builder_.add_deprecated_builtin_code(deprecated_builtin_code);
10201 return builder_.Finish();
10202}
10203
10204inline flatbuffers::Offset<OperatorCode> CreateOperatorCodeDirect(
10205 flatbuffers::FlatBufferBuilder &_fbb,
10206 int8_t deprecated_builtin_code = 0,
10207 const char *custom_code = nullptr,
10208 int32_t version = 1,
10209 tflite::BuiltinOperator builtin_code = tflite::BuiltinOperator_ADD) {
10210 auto custom_code__ = custom_code ? _fbb.CreateString(custom_code) : 0;
10211 return tflite::CreateOperatorCode(
10212 _fbb,
10213 deprecated_builtin_code,
10214 custom_code__,
10215 version,
10216 builtin_code);
10217}
10218
10219flatbuffers::Offset<OperatorCode> CreateOperatorCode(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10220
10221struct OperatorT : public flatbuffers::NativeTable {
10222 typedef Operator TableType;
10223 uint32_t opcode_index;
10224 std::vector<int32_t> inputs;
10225 std::vector<int32_t> outputs;
10226 tflite::BuiltinOptionsUnion builtin_options;
10227 std::vector<uint8_t> custom_options;
10228 tflite::CustomOptionsFormat custom_options_format;
10229 std::vector<bool> mutating_variable_inputs;
10230 std::vector<int32_t> intermediates;
10231 OperatorT()
10232 : opcode_index(0),
10233 custom_options_format(tflite::CustomOptionsFormat_FLEXBUFFERS) {
10234 }
10235};
10236
10237struct Operator FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10238 typedef OperatorT NativeTableType;
10239 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10240 VT_OPCODE_INDEX = 4,
10241 VT_INPUTS = 6,
10242 VT_OUTPUTS = 8,
10243 VT_BUILTIN_OPTIONS_TYPE = 10,
10244 VT_BUILTIN_OPTIONS = 12,
10245 VT_CUSTOM_OPTIONS = 14,
10246 VT_CUSTOM_OPTIONS_FORMAT = 16,
10247 VT_MUTATING_VARIABLE_INPUTS = 18,
10248 VT_INTERMEDIATES = 20
10249 };
10250 uint32_t opcode_index() const {
10251 return GetField<uint32_t>(VT_OPCODE_INDEX, 0);
10252 }
10253 const flatbuffers::Vector<int32_t> *inputs() const {
10254 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_INPUTS);
10255 }
10256 const flatbuffers::Vector<int32_t> *outputs() const {
10257 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OUTPUTS);
10258 }
10259 tflite::BuiltinOptions builtin_options_type() const {
10260 return static_cast<tflite::BuiltinOptions>(GetField<uint8_t>(VT_BUILTIN_OPTIONS_TYPE, 0));
10261 }
10262 const void *builtin_options() const {
10263 return GetPointer<const void *>(VT_BUILTIN_OPTIONS);
10264 }
10265 template<typename T> const T *builtin_options_as() const;
10266 const tflite::Conv2DOptions *builtin_options_as_Conv2DOptions() const {
10267 return builtin_options_type() == tflite::BuiltinOptions_Conv2DOptions ? static_cast<const tflite::Conv2DOptions *>(builtin_options()) : nullptr;
10268 }
10269 const tflite::DepthwiseConv2DOptions *builtin_options_as_DepthwiseConv2DOptions() const {
10270 return builtin_options_type() == tflite::BuiltinOptions_DepthwiseConv2DOptions ? static_cast<const tflite::DepthwiseConv2DOptions *>(builtin_options()) : nullptr;
10271 }
10272 const tflite::ConcatEmbeddingsOptions *builtin_options_as_ConcatEmbeddingsOptions() const {
10273 return builtin_options_type() == tflite::BuiltinOptions_ConcatEmbeddingsOptions ? static_cast<const tflite::ConcatEmbeddingsOptions *>(builtin_options()) : nullptr;
10274 }
10275 const tflite::LSHProjectionOptions *builtin_options_as_LSHProjectionOptions() const {
10276 return builtin_options_type() == tflite::BuiltinOptions_LSHProjectionOptions ? static_cast<const tflite::LSHProjectionOptions *>(builtin_options()) : nullptr;
10277 }
10278 const tflite::Pool2DOptions *builtin_options_as_Pool2DOptions() const {
10279 return builtin_options_type() == tflite::BuiltinOptions_Pool2DOptions ? static_cast<const tflite::Pool2DOptions *>(builtin_options()) : nullptr;
10280 }
10281 const tflite::SVDFOptions *builtin_options_as_SVDFOptions() const {
10282 return builtin_options_type() == tflite::BuiltinOptions_SVDFOptions ? static_cast<const tflite::SVDFOptions *>(builtin_options()) : nullptr;
10283 }
10284 const tflite::RNNOptions *builtin_options_as_RNNOptions() const {
10285 return builtin_options_type() == tflite::BuiltinOptions_RNNOptions ? static_cast<const tflite::RNNOptions *>(builtin_options()) : nullptr;
10286 }
10287 const tflite::FullyConnectedOptions *builtin_options_as_FullyConnectedOptions() const {
10288 return builtin_options_type() == tflite::BuiltinOptions_FullyConnectedOptions ? static_cast<const tflite::FullyConnectedOptions *>(builtin_options()) : nullptr;
10289 }
10290 const tflite::SoftmaxOptions *builtin_options_as_SoftmaxOptions() const {
10291 return builtin_options_type() == tflite::BuiltinOptions_SoftmaxOptions ? static_cast<const tflite::SoftmaxOptions *>(builtin_options()) : nullptr;
10292 }
10293 const tflite::ConcatenationOptions *builtin_options_as_ConcatenationOptions() const {
10294 return builtin_options_type() == tflite::BuiltinOptions_ConcatenationOptions ? static_cast<const tflite::ConcatenationOptions *>(builtin_options()) : nullptr;
10295 }
10296 const tflite::AddOptions *builtin_options_as_AddOptions() const {
10297 return builtin_options_type() == tflite::BuiltinOptions_AddOptions ? static_cast<const tflite::AddOptions *>(builtin_options()) : nullptr;
10298 }
10299 const tflite::L2NormOptions *builtin_options_as_L2NormOptions() const {
10300 return builtin_options_type() == tflite::BuiltinOptions_L2NormOptions ? static_cast<const tflite::L2NormOptions *>(builtin_options()) : nullptr;
10301 }
10302 const tflite::LocalResponseNormalizationOptions *builtin_options_as_LocalResponseNormalizationOptions() const {
10303 return builtin_options_type() == tflite::BuiltinOptions_LocalResponseNormalizationOptions ? static_cast<const tflite::LocalResponseNormalizationOptions *>(builtin_options()) : nullptr;
10304 }
10305 const tflite::LSTMOptions *builtin_options_as_LSTMOptions() const {
10306 return builtin_options_type() == tflite::BuiltinOptions_LSTMOptions ? static_cast<const tflite::LSTMOptions *>(builtin_options()) : nullptr;
10307 }
10308 const tflite::ResizeBilinearOptions *builtin_options_as_ResizeBilinearOptions() const {
10309 return builtin_options_type() == tflite::BuiltinOptions_ResizeBilinearOptions ? static_cast<const tflite::ResizeBilinearOptions *>(builtin_options()) : nullptr;
10310 }
10311 const tflite::CallOptions *builtin_options_as_CallOptions() const {
10312 return builtin_options_type() == tflite::BuiltinOptions_CallOptions ? static_cast<const tflite::CallOptions *>(builtin_options()) : nullptr;
10313 }
10314 const tflite::ReshapeOptions *builtin_options_as_ReshapeOptions() const {
10315 return builtin_options_type() == tflite::BuiltinOptions_ReshapeOptions ? static_cast<const tflite::ReshapeOptions *>(builtin_options()) : nullptr;
10316 }
10317 const tflite::SkipGramOptions *builtin_options_as_SkipGramOptions() const {
10318 return builtin_options_type() == tflite::BuiltinOptions_SkipGramOptions ? static_cast<const tflite::SkipGramOptions *>(builtin_options()) : nullptr;
10319 }
10320 const tflite::SpaceToDepthOptions *builtin_options_as_SpaceToDepthOptions() const {
10321 return builtin_options_type() == tflite::BuiltinOptions_SpaceToDepthOptions ? static_cast<const tflite::SpaceToDepthOptions *>(builtin_options()) : nullptr;
10322 }
10323 const tflite::EmbeddingLookupSparseOptions *builtin_options_as_EmbeddingLookupSparseOptions() const {
10324 return builtin_options_type() == tflite::BuiltinOptions_EmbeddingLookupSparseOptions ? static_cast<const tflite::EmbeddingLookupSparseOptions *>(builtin_options()) : nullptr;
10325 }
10326 const tflite::MulOptions *builtin_options_as_MulOptions() const {
10327 return builtin_options_type() == tflite::BuiltinOptions_MulOptions ? static_cast<const tflite::MulOptions *>(builtin_options()) : nullptr;
10328 }
10329 const tflite::PadOptions *builtin_options_as_PadOptions() const {
10330 return builtin_options_type() == tflite::BuiltinOptions_PadOptions ? static_cast<const tflite::PadOptions *>(builtin_options()) : nullptr;
10331 }
10332 const tflite::GatherOptions *builtin_options_as_GatherOptions() const {
10333 return builtin_options_type() == tflite::BuiltinOptions_GatherOptions ? static_cast<const tflite::GatherOptions *>(builtin_options()) : nullptr;
10334 }
10335 const tflite::BatchToSpaceNDOptions *builtin_options_as_BatchToSpaceNDOptions() const {
10336 return builtin_options_type() == tflite::BuiltinOptions_BatchToSpaceNDOptions ? static_cast<const tflite::BatchToSpaceNDOptions *>(builtin_options()) : nullptr;
10337 }
10338 const tflite::SpaceToBatchNDOptions *builtin_options_as_SpaceToBatchNDOptions() const {
10339 return builtin_options_type() == tflite::BuiltinOptions_SpaceToBatchNDOptions ? static_cast<const tflite::SpaceToBatchNDOptions *>(builtin_options()) : nullptr;
10340 }
10341 const tflite::TransposeOptions *builtin_options_as_TransposeOptions() const {
10342 return builtin_options_type() == tflite::BuiltinOptions_TransposeOptions ? static_cast<const tflite::TransposeOptions *>(builtin_options()) : nullptr;
10343 }
10344 const tflite::ReducerOptions *builtin_options_as_ReducerOptions() const {
10345 return builtin_options_type() == tflite::BuiltinOptions_ReducerOptions ? static_cast<const tflite::ReducerOptions *>(builtin_options()) : nullptr;
10346 }
10347 const tflite::SubOptions *builtin_options_as_SubOptions() const {
10348 return builtin_options_type() == tflite::BuiltinOptions_SubOptions ? static_cast<const tflite::SubOptions *>(builtin_options()) : nullptr;
10349 }
10350 const tflite::DivOptions *builtin_options_as_DivOptions() const {
10351 return builtin_options_type() == tflite::BuiltinOptions_DivOptions ? static_cast<const tflite::DivOptions *>(builtin_options()) : nullptr;
10352 }
10353 const tflite::SqueezeOptions *builtin_options_as_SqueezeOptions() const {
10354 return builtin_options_type() == tflite::BuiltinOptions_SqueezeOptions ? static_cast<const tflite::SqueezeOptions *>(builtin_options()) : nullptr;
10355 }
10356 const tflite::SequenceRNNOptions *builtin_options_as_SequenceRNNOptions() const {
10357 return builtin_options_type() == tflite::BuiltinOptions_SequenceRNNOptions ? static_cast<const tflite::SequenceRNNOptions *>(builtin_options()) : nullptr;
10358 }
10359 const tflite::StridedSliceOptions *builtin_options_as_StridedSliceOptions() const {
10360 return builtin_options_type() == tflite::BuiltinOptions_StridedSliceOptions ? static_cast<const tflite::StridedSliceOptions *>(builtin_options()) : nullptr;
10361 }
10362 const tflite::ExpOptions *builtin_options_as_ExpOptions() const {
10363 return builtin_options_type() == tflite::BuiltinOptions_ExpOptions ? static_cast<const tflite::ExpOptions *>(builtin_options()) : nullptr;
10364 }
10365 const tflite::TopKV2Options *builtin_options_as_TopKV2Options() const {
10366 return builtin_options_type() == tflite::BuiltinOptions_TopKV2Options ? static_cast<const tflite::TopKV2Options *>(builtin_options()) : nullptr;
10367 }
10368 const tflite::SplitOptions *builtin_options_as_SplitOptions() const {
10369 return builtin_options_type() == tflite::BuiltinOptions_SplitOptions ? static_cast<const tflite::SplitOptions *>(builtin_options()) : nullptr;
10370 }
10371 const tflite::LogSoftmaxOptions *builtin_options_as_LogSoftmaxOptions() const {
10372 return builtin_options_type() == tflite::BuiltinOptions_LogSoftmaxOptions ? static_cast<const tflite::LogSoftmaxOptions *>(builtin_options()) : nullptr;
10373 }
10374 const tflite::CastOptions *builtin_options_as_CastOptions() const {
10375 return builtin_options_type() == tflite::BuiltinOptions_CastOptions ? static_cast<const tflite::CastOptions *>(builtin_options()) : nullptr;
10376 }
10377 const tflite::DequantizeOptions *builtin_options_as_DequantizeOptions() const {
10378 return builtin_options_type() == tflite::BuiltinOptions_DequantizeOptions ? static_cast<const tflite::DequantizeOptions *>(builtin_options()) : nullptr;
10379 }
10380 const tflite::MaximumMinimumOptions *builtin_options_as_MaximumMinimumOptions() const {
10381 return builtin_options_type() == tflite::BuiltinOptions_MaximumMinimumOptions ? static_cast<const tflite::MaximumMinimumOptions *>(builtin_options()) : nullptr;
10382 }
10383 const tflite::ArgMaxOptions *builtin_options_as_ArgMaxOptions() const {
10384 return builtin_options_type() == tflite::BuiltinOptions_ArgMaxOptions ? static_cast<const tflite::ArgMaxOptions *>(builtin_options()) : nullptr;
10385 }
10386 const tflite::LessOptions *builtin_options_as_LessOptions() const {
10387 return builtin_options_type() == tflite::BuiltinOptions_LessOptions ? static_cast<const tflite::LessOptions *>(builtin_options()) : nullptr;
10388 }
10389 const tflite::NegOptions *builtin_options_as_NegOptions() const {
10390 return builtin_options_type() == tflite::BuiltinOptions_NegOptions ? static_cast<const tflite::NegOptions *>(builtin_options()) : nullptr;
10391 }
10392 const tflite::PadV2Options *builtin_options_as_PadV2Options() const {
10393 return builtin_options_type() == tflite::BuiltinOptions_PadV2Options ? static_cast<const tflite::PadV2Options *>(builtin_options()) : nullptr;
10394 }
10395 const tflite::GreaterOptions *builtin_options_as_GreaterOptions() const {
10396 return builtin_options_type() == tflite::BuiltinOptions_GreaterOptions ? static_cast<const tflite::GreaterOptions *>(builtin_options()) : nullptr;
10397 }
10398 const tflite::GreaterEqualOptions *builtin_options_as_GreaterEqualOptions() const {
10399 return builtin_options_type() == tflite::BuiltinOptions_GreaterEqualOptions ? static_cast<const tflite::GreaterEqualOptions *>(builtin_options()) : nullptr;
10400 }
10401 const tflite::LessEqualOptions *builtin_options_as_LessEqualOptions() const {
10402 return builtin_options_type() == tflite::BuiltinOptions_LessEqualOptions ? static_cast<const tflite::LessEqualOptions *>(builtin_options()) : nullptr;
10403 }
10404 const tflite::SelectOptions *builtin_options_as_SelectOptions() const {
10405 return builtin_options_type() == tflite::BuiltinOptions_SelectOptions ? static_cast<const tflite::SelectOptions *>(builtin_options()) : nullptr;
10406 }
10407 const tflite::SliceOptions *builtin_options_as_SliceOptions() const {
10408 return builtin_options_type() == tflite::BuiltinOptions_SliceOptions ? static_cast<const tflite::SliceOptions *>(builtin_options()) : nullptr;
10409 }
10410 const tflite::TransposeConvOptions *builtin_options_as_TransposeConvOptions() const {
10411 return builtin_options_type() == tflite::BuiltinOptions_TransposeConvOptions ? static_cast<const tflite::TransposeConvOptions *>(builtin_options()) : nullptr;
10412 }
10413 const tflite::SparseToDenseOptions *builtin_options_as_SparseToDenseOptions() const {
10414 return builtin_options_type() == tflite::BuiltinOptions_SparseToDenseOptions ? static_cast<const tflite::SparseToDenseOptions *>(builtin_options()) : nullptr;
10415 }
10416 const tflite::TileOptions *builtin_options_as_TileOptions() const {
10417 return builtin_options_type() == tflite::BuiltinOptions_TileOptions ? static_cast<const tflite::TileOptions *>(builtin_options()) : nullptr;
10418 }
10419 const tflite::ExpandDimsOptions *builtin_options_as_ExpandDimsOptions() const {
10420 return builtin_options_type() == tflite::BuiltinOptions_ExpandDimsOptions ? static_cast<const tflite::ExpandDimsOptions *>(builtin_options()) : nullptr;
10421 }
10422 const tflite::EqualOptions *builtin_options_as_EqualOptions() const {
10423 return builtin_options_type() == tflite::BuiltinOptions_EqualOptions ? static_cast<const tflite::EqualOptions *>(builtin_options()) : nullptr;
10424 }
10425 const tflite::NotEqualOptions *builtin_options_as_NotEqualOptions() const {
10426 return builtin_options_type() == tflite::BuiltinOptions_NotEqualOptions ? static_cast<const tflite::NotEqualOptions *>(builtin_options()) : nullptr;
10427 }
10428 const tflite::ShapeOptions *builtin_options_as_ShapeOptions() const {
10429 return builtin_options_type() == tflite::BuiltinOptions_ShapeOptions ? static_cast<const tflite::ShapeOptions *>(builtin_options()) : nullptr;
10430 }
10431 const tflite::PowOptions *builtin_options_as_PowOptions() const {
10432 return builtin_options_type() == tflite::BuiltinOptions_PowOptions ? static_cast<const tflite::PowOptions *>(builtin_options()) : nullptr;
10433 }
10434 const tflite::ArgMinOptions *builtin_options_as_ArgMinOptions() const {
10435 return builtin_options_type() == tflite::BuiltinOptions_ArgMinOptions ? static_cast<const tflite::ArgMinOptions *>(builtin_options()) : nullptr;
10436 }
10437 const tflite::FakeQuantOptions *builtin_options_as_FakeQuantOptions() const {
10438 return builtin_options_type() == tflite::BuiltinOptions_FakeQuantOptions ? static_cast<const tflite::FakeQuantOptions *>(builtin_options()) : nullptr;
10439 }
10440 const tflite::PackOptions *builtin_options_as_PackOptions() const {
10441 return builtin_options_type() == tflite::BuiltinOptions_PackOptions ? static_cast<const tflite::PackOptions *>(builtin_options()) : nullptr;
10442 }
10443 const tflite::LogicalOrOptions *builtin_options_as_LogicalOrOptions() const {
10444 return builtin_options_type() == tflite::BuiltinOptions_LogicalOrOptions ? static_cast<const tflite::LogicalOrOptions *>(builtin_options()) : nullptr;
10445 }
10446 const tflite::OneHotOptions *builtin_options_as_OneHotOptions() const {
10447 return builtin_options_type() == tflite::BuiltinOptions_OneHotOptions ? static_cast<const tflite::OneHotOptions *>(builtin_options()) : nullptr;
10448 }
10449 const tflite::LogicalAndOptions *builtin_options_as_LogicalAndOptions() const {
10450 return builtin_options_type() == tflite::BuiltinOptions_LogicalAndOptions ? static_cast<const tflite::LogicalAndOptions *>(builtin_options()) : nullptr;
10451 }
10452 const tflite::LogicalNotOptions *builtin_options_as_LogicalNotOptions() const {
10453 return builtin_options_type() == tflite::BuiltinOptions_LogicalNotOptions ? static_cast<const tflite::LogicalNotOptions *>(builtin_options()) : nullptr;
10454 }
10455 const tflite::UnpackOptions *builtin_options_as_UnpackOptions() const {
10456 return builtin_options_type() == tflite::BuiltinOptions_UnpackOptions ? static_cast<const tflite::UnpackOptions *>(builtin_options()) : nullptr;
10457 }
10458 const tflite::FloorDivOptions *builtin_options_as_FloorDivOptions() const {
10459 return builtin_options_type() == tflite::BuiltinOptions_FloorDivOptions ? static_cast<const tflite::FloorDivOptions *>(builtin_options()) : nullptr;
10460 }
10461 const tflite::SquareOptions *builtin_options_as_SquareOptions() const {
10462 return builtin_options_type() == tflite::BuiltinOptions_SquareOptions ? static_cast<const tflite::SquareOptions *>(builtin_options()) : nullptr;
10463 }
10464 const tflite::ZerosLikeOptions *builtin_options_as_ZerosLikeOptions() const {
10465 return builtin_options_type() == tflite::BuiltinOptions_ZerosLikeOptions ? static_cast<const tflite::ZerosLikeOptions *>(builtin_options()) : nullptr;
10466 }
10467 const tflite::FillOptions *builtin_options_as_FillOptions() const {
10468 return builtin_options_type() == tflite::BuiltinOptions_FillOptions ? static_cast<const tflite::FillOptions *>(builtin_options()) : nullptr;
10469 }
10470 const tflite::BidirectionalSequenceLSTMOptions *builtin_options_as_BidirectionalSequenceLSTMOptions() const {
10471 return builtin_options_type() == tflite::BuiltinOptions_BidirectionalSequenceLSTMOptions ? static_cast<const tflite::BidirectionalSequenceLSTMOptions *>(builtin_options()) : nullptr;
10472 }
10473 const tflite::BidirectionalSequenceRNNOptions *builtin_options_as_BidirectionalSequenceRNNOptions() const {
10474 return builtin_options_type() == tflite::BuiltinOptions_BidirectionalSequenceRNNOptions ? static_cast<const tflite::BidirectionalSequenceRNNOptions *>(builtin_options()) : nullptr;
10475 }
10476 const tflite::UnidirectionalSequenceLSTMOptions *builtin_options_as_UnidirectionalSequenceLSTMOptions() const {
10477 return builtin_options_type() == tflite::BuiltinOptions_UnidirectionalSequenceLSTMOptions ? static_cast<const tflite::UnidirectionalSequenceLSTMOptions *>(builtin_options()) : nullptr;
10478 }
10479 const tflite::FloorModOptions *builtin_options_as_FloorModOptions() const {
10480 return builtin_options_type() == tflite::BuiltinOptions_FloorModOptions ? static_cast<const tflite::FloorModOptions *>(builtin_options()) : nullptr;
10481 }
10482 const tflite::RangeOptions *builtin_options_as_RangeOptions() const {
10483 return builtin_options_type() == tflite::BuiltinOptions_RangeOptions ? static_cast<const tflite::RangeOptions *>(builtin_options()) : nullptr;
10484 }
10485 const tflite::ResizeNearestNeighborOptions *builtin_options_as_ResizeNearestNeighborOptions() const {
10486 return builtin_options_type() == tflite::BuiltinOptions_ResizeNearestNeighborOptions ? static_cast<const tflite::ResizeNearestNeighborOptions *>(builtin_options()) : nullptr;
10487 }
10488 const tflite::LeakyReluOptions *builtin_options_as_LeakyReluOptions() const {
10489 return builtin_options_type() == tflite::BuiltinOptions_LeakyReluOptions ? static_cast<const tflite::LeakyReluOptions *>(builtin_options()) : nullptr;
10490 }
10491 const tflite::SquaredDifferenceOptions *builtin_options_as_SquaredDifferenceOptions() const {
10492 return builtin_options_type() == tflite::BuiltinOptions_SquaredDifferenceOptions ? static_cast<const tflite::SquaredDifferenceOptions *>(builtin_options()) : nullptr;
10493 }
10494 const tflite::MirrorPadOptions *builtin_options_as_MirrorPadOptions() const {
10495 return builtin_options_type() == tflite::BuiltinOptions_MirrorPadOptions ? static_cast<const tflite::MirrorPadOptions *>(builtin_options()) : nullptr;
10496 }
10497 const tflite::AbsOptions *builtin_options_as_AbsOptions() const {
10498 return builtin_options_type() == tflite::BuiltinOptions_AbsOptions ? static_cast<const tflite::AbsOptions *>(builtin_options()) : nullptr;
10499 }
10500 const tflite::SplitVOptions *builtin_options_as_SplitVOptions() const {
10501 return builtin_options_type() == tflite::BuiltinOptions_SplitVOptions ? static_cast<const tflite::SplitVOptions *>(builtin_options()) : nullptr;
10502 }
10503 const tflite::UniqueOptions *builtin_options_as_UniqueOptions() const {
10504 return builtin_options_type() == tflite::BuiltinOptions_UniqueOptions ? static_cast<const tflite::UniqueOptions *>(builtin_options()) : nullptr;
10505 }
10506 const tflite::ReverseV2Options *builtin_options_as_ReverseV2Options() const {
10507 return builtin_options_type() == tflite::BuiltinOptions_ReverseV2Options ? static_cast<const tflite::ReverseV2Options *>(builtin_options()) : nullptr;
10508 }
10509 const tflite::AddNOptions *builtin_options_as_AddNOptions() const {
10510 return builtin_options_type() == tflite::BuiltinOptions_AddNOptions ? static_cast<const tflite::AddNOptions *>(builtin_options()) : nullptr;
10511 }
10512 const tflite::GatherNdOptions *builtin_options_as_GatherNdOptions() const {
10513 return builtin_options_type() == tflite::BuiltinOptions_GatherNdOptions ? static_cast<const tflite::GatherNdOptions *>(builtin_options()) : nullptr;
10514 }
10515 const tflite::CosOptions *builtin_options_as_CosOptions() const {
10516 return builtin_options_type() == tflite::BuiltinOptions_CosOptions ? static_cast<const tflite::CosOptions *>(builtin_options()) : nullptr;
10517 }
10518 const tflite::WhereOptions *builtin_options_as_WhereOptions() const {
10519 return builtin_options_type() == tflite::BuiltinOptions_WhereOptions ? static_cast<const tflite::WhereOptions *>(builtin_options()) : nullptr;
10520 }
10521 const tflite::RankOptions *builtin_options_as_RankOptions() const {
10522 return builtin_options_type() == tflite::BuiltinOptions_RankOptions ? static_cast<const tflite::RankOptions *>(builtin_options()) : nullptr;
10523 }
10524 const tflite::ReverseSequenceOptions *builtin_options_as_ReverseSequenceOptions() const {
10525 return builtin_options_type() == tflite::BuiltinOptions_ReverseSequenceOptions ? static_cast<const tflite::ReverseSequenceOptions *>(builtin_options()) : nullptr;
10526 }
10527 const tflite::MatrixDiagOptions *builtin_options_as_MatrixDiagOptions() const {
10528 return builtin_options_type() == tflite::BuiltinOptions_MatrixDiagOptions ? static_cast<const tflite::MatrixDiagOptions *>(builtin_options()) : nullptr;
10529 }
10530 const tflite::QuantizeOptions *builtin_options_as_QuantizeOptions() const {
10531 return builtin_options_type() == tflite::BuiltinOptions_QuantizeOptions ? static_cast<const tflite::QuantizeOptions *>(builtin_options()) : nullptr;
10532 }
10533 const tflite::MatrixSetDiagOptions *builtin_options_as_MatrixSetDiagOptions() const {
10534 return builtin_options_type() == tflite::BuiltinOptions_MatrixSetDiagOptions ? static_cast<const tflite::MatrixSetDiagOptions *>(builtin_options()) : nullptr;
10535 }
10536 const tflite::HardSwishOptions *builtin_options_as_HardSwishOptions() const {
10537 return builtin_options_type() == tflite::BuiltinOptions_HardSwishOptions ? static_cast<const tflite::HardSwishOptions *>(builtin_options()) : nullptr;
10538 }
10539 const tflite::IfOptions *builtin_options_as_IfOptions() const {
10540 return builtin_options_type() == tflite::BuiltinOptions_IfOptions ? static_cast<const tflite::IfOptions *>(builtin_options()) : nullptr;
10541 }
10542 const tflite::WhileOptions *builtin_options_as_WhileOptions() const {
10543 return builtin_options_type() == tflite::BuiltinOptions_WhileOptions ? static_cast<const tflite::WhileOptions *>(builtin_options()) : nullptr;
10544 }
10545 const tflite::DepthToSpaceOptions *builtin_options_as_DepthToSpaceOptions() const {
10546 return builtin_options_type() == tflite::BuiltinOptions_DepthToSpaceOptions ? static_cast<const tflite::DepthToSpaceOptions *>(builtin_options()) : nullptr;
10547 }
10548 const tflite::NonMaxSuppressionV4Options *builtin_options_as_NonMaxSuppressionV4Options() const {
10549 return builtin_options_type() == tflite::BuiltinOptions_NonMaxSuppressionV4Options ? static_cast<const tflite::NonMaxSuppressionV4Options *>(builtin_options()) : nullptr;
10550 }
10551 const tflite::NonMaxSuppressionV5Options *builtin_options_as_NonMaxSuppressionV5Options() const {
10552 return builtin_options_type() == tflite::BuiltinOptions_NonMaxSuppressionV5Options ? static_cast<const tflite::NonMaxSuppressionV5Options *>(builtin_options()) : nullptr;
10553 }
10554 const tflite::ScatterNdOptions *builtin_options_as_ScatterNdOptions() const {
10555 return builtin_options_type() == tflite::BuiltinOptions_ScatterNdOptions ? static_cast<const tflite::ScatterNdOptions *>(builtin_options()) : nullptr;
10556 }
10557 const tflite::SelectV2Options *builtin_options_as_SelectV2Options() const {
10558 return builtin_options_type() == tflite::BuiltinOptions_SelectV2Options ? static_cast<const tflite::SelectV2Options *>(builtin_options()) : nullptr;
10559 }
10560 const tflite::DensifyOptions *builtin_options_as_DensifyOptions() const {
10561 return builtin_options_type() == tflite::BuiltinOptions_DensifyOptions ? static_cast<const tflite::DensifyOptions *>(builtin_options()) : nullptr;
10562 }
10563 const tflite::SegmentSumOptions *builtin_options_as_SegmentSumOptions() const {
10564 return builtin_options_type() == tflite::BuiltinOptions_SegmentSumOptions ? static_cast<const tflite::SegmentSumOptions *>(builtin_options()) : nullptr;
10565 }
10566 const tflite::BatchMatMulOptions *builtin_options_as_BatchMatMulOptions() const {
10567 return builtin_options_type() == tflite::BuiltinOptions_BatchMatMulOptions ? static_cast<const tflite::BatchMatMulOptions *>(builtin_options()) : nullptr;
10568 }
10569 const tflite::CumsumOptions *builtin_options_as_CumsumOptions() const {
10570 return builtin_options_type() == tflite::BuiltinOptions_CumsumOptions ? static_cast<const tflite::CumsumOptions *>(builtin_options()) : nullptr;
10571 }
10572 const tflite::CallOnceOptions *builtin_options_as_CallOnceOptions() const {
10573 return builtin_options_type() == tflite::BuiltinOptions_CallOnceOptions ? static_cast<const tflite::CallOnceOptions *>(builtin_options()) : nullptr;
10574 }
10575 const tflite::BroadcastToOptions *builtin_options_as_BroadcastToOptions() const {
10576 return builtin_options_type() == tflite::BuiltinOptions_BroadcastToOptions ? static_cast<const tflite::BroadcastToOptions *>(builtin_options()) : nullptr;
10577 }
10578 const tflite::Rfft2dOptions *builtin_options_as_Rfft2dOptions() const {
10579 return builtin_options_type() == tflite::BuiltinOptions_Rfft2dOptions ? static_cast<const tflite::Rfft2dOptions *>(builtin_options()) : nullptr;
10580 }
10581 const tflite::Conv3DOptions *builtin_options_as_Conv3DOptions() const {
10582 return builtin_options_type() == tflite::BuiltinOptions_Conv3DOptions ? static_cast<const tflite::Conv3DOptions *>(builtin_options()) : nullptr;
10583 }
10584 const tflite::HashtableOptions *builtin_options_as_HashtableOptions() const {
10585 return builtin_options_type() == tflite::BuiltinOptions_HashtableOptions ? static_cast<const tflite::HashtableOptions *>(builtin_options()) : nullptr;
10586 }
10587 const tflite::HashtableFindOptions *builtin_options_as_HashtableFindOptions() const {
10588 return builtin_options_type() == tflite::BuiltinOptions_HashtableFindOptions ? static_cast<const tflite::HashtableFindOptions *>(builtin_options()) : nullptr;
10589 }
10590 const tflite::HashtableImportOptions *builtin_options_as_HashtableImportOptions() const {
10591 return builtin_options_type() == tflite::BuiltinOptions_HashtableImportOptions ? static_cast<const tflite::HashtableImportOptions *>(builtin_options()) : nullptr;
10592 }
10593 const tflite::HashtableSizeOptions *builtin_options_as_HashtableSizeOptions() const {
10594 return builtin_options_type() == tflite::BuiltinOptions_HashtableSizeOptions ? static_cast<const tflite::HashtableSizeOptions *>(builtin_options()) : nullptr;
10595 }
10596 const flatbuffers::Vector<uint8_t> *custom_options() const {
10597 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_CUSTOM_OPTIONS);
10598 }
10599 tflite::CustomOptionsFormat custom_options_format() const {
10600 return static_cast<tflite::CustomOptionsFormat>(GetField<int8_t>(VT_CUSTOM_OPTIONS_FORMAT, 0));
10601 }
10602 const flatbuffers::Vector<uint8_t> *mutating_variable_inputs() const {
10603 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_MUTATING_VARIABLE_INPUTS);
10604 }
10605 const flatbuffers::Vector<int32_t> *intermediates() const {
10606 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_INTERMEDIATES);
10607 }
10608 bool Verify(flatbuffers::Verifier &verifier) const {
10609 return VerifyTableStart(verifier) &&
10610 VerifyField<uint32_t>(verifier, VT_OPCODE_INDEX) &&
10611 VerifyOffset(verifier, VT_INPUTS) &&
10612 verifier.VerifyVector(inputs()) &&
10613 VerifyOffset(verifier, VT_OUTPUTS) &&
10614 verifier.VerifyVector(outputs()) &&
10615 VerifyField<uint8_t>(verifier, VT_BUILTIN_OPTIONS_TYPE) &&
10616 VerifyOffset(verifier, VT_BUILTIN_OPTIONS) &&
10617 VerifyBuiltinOptions(verifier, builtin_options(), builtin_options_type()) &&
10618 VerifyOffset(verifier, VT_CUSTOM_OPTIONS) &&
10619 verifier.VerifyVector(custom_options()) &&
10620 VerifyField<int8_t>(verifier, VT_CUSTOM_OPTIONS_FORMAT) &&
10621 VerifyOffset(verifier, VT_MUTATING_VARIABLE_INPUTS) &&
10622 verifier.VerifyVector(mutating_variable_inputs()) &&
10623 VerifyOffset(verifier, VT_INTERMEDIATES) &&
10624 verifier.VerifyVector(intermediates()) &&
10625 verifier.EndTable();
10626 }
10627 OperatorT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10628 void UnPackTo(OperatorT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10629 static flatbuffers::Offset<Operator> Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10630};
10631
10632template<> inline const tflite::Conv2DOptions *Operator::builtin_options_as<tflite::Conv2DOptions>() const {
10633 return builtin_options_as_Conv2DOptions();
10634}
10635
10636template<> inline const tflite::DepthwiseConv2DOptions *Operator::builtin_options_as<tflite::DepthwiseConv2DOptions>() const {
10637 return builtin_options_as_DepthwiseConv2DOptions();
10638}
10639
10640template<> inline const tflite::ConcatEmbeddingsOptions *Operator::builtin_options_as<tflite::ConcatEmbeddingsOptions>() const {
10641 return builtin_options_as_ConcatEmbeddingsOptions();
10642}
10643
10644template<> inline const tflite::LSHProjectionOptions *Operator::builtin_options_as<tflite::LSHProjectionOptions>() const {
10645 return builtin_options_as_LSHProjectionOptions();
10646}
10647
10648template<> inline const tflite::Pool2DOptions *Operator::builtin_options_as<tflite::Pool2DOptions>() const {
10649 return builtin_options_as_Pool2DOptions();
10650}
10651
10652template<> inline const tflite::SVDFOptions *Operator::builtin_options_as<tflite::SVDFOptions>() const {
10653 return builtin_options_as_SVDFOptions();
10654}
10655
10656template<> inline const tflite::RNNOptions *Operator::builtin_options_as<tflite::RNNOptions>() const {
10657 return builtin_options_as_RNNOptions();
10658}
10659
10660template<> inline const tflite::FullyConnectedOptions *Operator::builtin_options_as<tflite::FullyConnectedOptions>() const {
10661 return builtin_options_as_FullyConnectedOptions();
10662}
10663
10664template<> inline const tflite::SoftmaxOptions *Operator::builtin_options_as<tflite::SoftmaxOptions>() const {
10665 return builtin_options_as_SoftmaxOptions();
10666}
10667
10668template<> inline const tflite::ConcatenationOptions *Operator::builtin_options_as<tflite::ConcatenationOptions>() const {
10669 return builtin_options_as_ConcatenationOptions();
10670}
10671
10672template<> inline const tflite::AddOptions *Operator::builtin_options_as<tflite::AddOptions>() const {
10673 return builtin_options_as_AddOptions();
10674}
10675
10676template<> inline const tflite::L2NormOptions *Operator::builtin_options_as<tflite::L2NormOptions>() const {
10677 return builtin_options_as_L2NormOptions();
10678}
10679
10680template<> inline const tflite::LocalResponseNormalizationOptions *Operator::builtin_options_as<tflite::LocalResponseNormalizationOptions>() const {
10681 return builtin_options_as_LocalResponseNormalizationOptions();
10682}
10683
10684template<> inline const tflite::LSTMOptions *Operator::builtin_options_as<tflite::LSTMOptions>() const {
10685 return builtin_options_as_LSTMOptions();
10686}
10687
10688template<> inline const tflite::ResizeBilinearOptions *Operator::builtin_options_as<tflite::ResizeBilinearOptions>() const {
10689 return builtin_options_as_ResizeBilinearOptions();
10690}
10691
10692template<> inline const tflite::CallOptions *Operator::builtin_options_as<tflite::CallOptions>() const {
10693 return builtin_options_as_CallOptions();
10694}
10695
10696template<> inline const tflite::ReshapeOptions *Operator::builtin_options_as<tflite::ReshapeOptions>() const {
10697 return builtin_options_as_ReshapeOptions();
10698}
10699
10700template<> inline const tflite::SkipGramOptions *Operator::builtin_options_as<tflite::SkipGramOptions>() const {
10701 return builtin_options_as_SkipGramOptions();
10702}
10703
10704template<> inline const tflite::SpaceToDepthOptions *Operator::builtin_options_as<tflite::SpaceToDepthOptions>() const {
10705 return builtin_options_as_SpaceToDepthOptions();
10706}
10707
10708template<> inline const tflite::EmbeddingLookupSparseOptions *Operator::builtin_options_as<tflite::EmbeddingLookupSparseOptions>() const {
10709 return builtin_options_as_EmbeddingLookupSparseOptions();
10710}
10711
10712template<> inline const tflite::MulOptions *Operator::builtin_options_as<tflite::MulOptions>() const {
10713 return builtin_options_as_MulOptions();
10714}
10715
10716template<> inline const tflite::PadOptions *Operator::builtin_options_as<tflite::PadOptions>() const {
10717 return builtin_options_as_PadOptions();
10718}
10719
10720template<> inline const tflite::GatherOptions *Operator::builtin_options_as<tflite::GatherOptions>() const {
10721 return builtin_options_as_GatherOptions();
10722}
10723
10724template<> inline const tflite::BatchToSpaceNDOptions *Operator::builtin_options_as<tflite::BatchToSpaceNDOptions>() const {
10725 return builtin_options_as_BatchToSpaceNDOptions();
10726}
10727
10728template<> inline const tflite::SpaceToBatchNDOptions *Operator::builtin_options_as<tflite::SpaceToBatchNDOptions>() const {
10729 return builtin_options_as_SpaceToBatchNDOptions();
10730}
10731
10732template<> inline const tflite::TransposeOptions *Operator::builtin_options_as<tflite::TransposeOptions>() const {
10733 return builtin_options_as_TransposeOptions();
10734}
10735
10736template<> inline const tflite::ReducerOptions *Operator::builtin_options_as<tflite::ReducerOptions>() const {
10737 return builtin_options_as_ReducerOptions();
10738}
10739
10740template<> inline const tflite::SubOptions *Operator::builtin_options_as<tflite::SubOptions>() const {
10741 return builtin_options_as_SubOptions();
10742}
10743
10744template<> inline const tflite::DivOptions *Operator::builtin_options_as<tflite::DivOptions>() const {
10745 return builtin_options_as_DivOptions();
10746}
10747
10748template<> inline const tflite::SqueezeOptions *Operator::builtin_options_as<tflite::SqueezeOptions>() const {
10749 return builtin_options_as_SqueezeOptions();
10750}
10751
10752template<> inline const tflite::SequenceRNNOptions *Operator::builtin_options_as<tflite::SequenceRNNOptions>() const {
10753 return builtin_options_as_SequenceRNNOptions();
10754}
10755
10756template<> inline const tflite::StridedSliceOptions *Operator::builtin_options_as<tflite::StridedSliceOptions>() const {
10757 return builtin_options_as_StridedSliceOptions();
10758}
10759
10760template<> inline const tflite::ExpOptions *Operator::builtin_options_as<tflite::ExpOptions>() const {
10761 return builtin_options_as_ExpOptions();
10762}
10763
10764template<> inline const tflite::TopKV2Options *Operator::builtin_options_as<tflite::TopKV2Options>() const {
10765 return builtin_options_as_TopKV2Options();
10766}
10767
10768template<> inline const tflite::SplitOptions *Operator::builtin_options_as<tflite::SplitOptions>() const {
10769 return builtin_options_as_SplitOptions();
10770}
10771
10772template<> inline const tflite::LogSoftmaxOptions *Operator::builtin_options_as<tflite::LogSoftmaxOptions>() const {
10773 return builtin_options_as_LogSoftmaxOptions();
10774}
10775
10776template<> inline const tflite::CastOptions *Operator::builtin_options_as<tflite::CastOptions>() const {
10777 return builtin_options_as_CastOptions();
10778}
10779
10780template<> inline const tflite::DequantizeOptions *Operator::builtin_options_as<tflite::DequantizeOptions>() const {
10781 return builtin_options_as_DequantizeOptions();
10782}
10783
10784template<> inline const tflite::MaximumMinimumOptions *Operator::builtin_options_as<tflite::MaximumMinimumOptions>() const {
10785 return builtin_options_as_MaximumMinimumOptions();
10786}
10787
10788template<> inline const tflite::ArgMaxOptions *Operator::builtin_options_as<tflite::ArgMaxOptions>() const {
10789 return builtin_options_as_ArgMaxOptions();
10790}
10791
10792template<> inline const tflite::LessOptions *Operator::builtin_options_as<tflite::LessOptions>() const {
10793 return builtin_options_as_LessOptions();
10794}
10795
10796template<> inline const tflite::NegOptions *Operator::builtin_options_as<tflite::NegOptions>() const {
10797 return builtin_options_as_NegOptions();
10798}
10799
10800template<> inline const tflite::PadV2Options *Operator::builtin_options_as<tflite::PadV2Options>() const {
10801 return builtin_options_as_PadV2Options();
10802}
10803
10804template<> inline const tflite::GreaterOptions *Operator::builtin_options_as<tflite::GreaterOptions>() const {
10805 return builtin_options_as_GreaterOptions();
10806}
10807
10808template<> inline const tflite::GreaterEqualOptions *Operator::builtin_options_as<tflite::GreaterEqualOptions>() const {
10809 return builtin_options_as_GreaterEqualOptions();
10810}
10811
10812template<> inline const tflite::LessEqualOptions *Operator::builtin_options_as<tflite::LessEqualOptions>() const {
10813 return builtin_options_as_LessEqualOptions();
10814}
10815
10816template<> inline const tflite::SelectOptions *Operator::builtin_options_as<tflite::SelectOptions>() const {
10817 return builtin_options_as_SelectOptions();
10818}
10819
10820template<> inline const tflite::SliceOptions *Operator::builtin_options_as<tflite::SliceOptions>() const {
10821 return builtin_options_as_SliceOptions();
10822}
10823
10824template<> inline const tflite::TransposeConvOptions *Operator::builtin_options_as<tflite::TransposeConvOptions>() const {
10825 return builtin_options_as_TransposeConvOptions();
10826}
10827
10828template<> inline const tflite::SparseToDenseOptions *Operator::builtin_options_as<tflite::SparseToDenseOptions>() const {
10829 return builtin_options_as_SparseToDenseOptions();
10830}
10831
10832template<> inline const tflite::TileOptions *Operator::builtin_options_as<tflite::TileOptions>() const {
10833 return builtin_options_as_TileOptions();
10834}
10835
10836template<> inline const tflite::ExpandDimsOptions *Operator::builtin_options_as<tflite::ExpandDimsOptions>() const {
10837 return builtin_options_as_ExpandDimsOptions();
10838}
10839
10840template<> inline const tflite::EqualOptions *Operator::builtin_options_as<tflite::EqualOptions>() const {
10841 return builtin_options_as_EqualOptions();
10842}
10843
10844template<> inline const tflite::NotEqualOptions *Operator::builtin_options_as<tflite::NotEqualOptions>() const {
10845 return builtin_options_as_NotEqualOptions();
10846}
10847
10848template<> inline const tflite::ShapeOptions *Operator::builtin_options_as<tflite::ShapeOptions>() const {
10849 return builtin_options_as_ShapeOptions();
10850}
10851
10852template<> inline const tflite::PowOptions *Operator::builtin_options_as<tflite::PowOptions>() const {
10853 return builtin_options_as_PowOptions();
10854}
10855
10856template<> inline const tflite::ArgMinOptions *Operator::builtin_options_as<tflite::ArgMinOptions>() const {
10857 return builtin_options_as_ArgMinOptions();
10858}
10859
10860template<> inline const tflite::FakeQuantOptions *Operator::builtin_options_as<tflite::FakeQuantOptions>() const {
10861 return builtin_options_as_FakeQuantOptions();
10862}
10863
10864template<> inline const tflite::PackOptions *Operator::builtin_options_as<tflite::PackOptions>() const {
10865 return builtin_options_as_PackOptions();
10866}
10867
10868template<> inline const tflite::LogicalOrOptions *Operator::builtin_options_as<tflite::LogicalOrOptions>() const {
10869 return builtin_options_as_LogicalOrOptions();
10870}
10871
10872template<> inline const tflite::OneHotOptions *Operator::builtin_options_as<tflite::OneHotOptions>() const {
10873 return builtin_options_as_OneHotOptions();
10874}
10875
10876template<> inline const tflite::LogicalAndOptions *Operator::builtin_options_as<tflite::LogicalAndOptions>() const {
10877 return builtin_options_as_LogicalAndOptions();
10878}
10879
10880template<> inline const tflite::LogicalNotOptions *Operator::builtin_options_as<tflite::LogicalNotOptions>() const {
10881 return builtin_options_as_LogicalNotOptions();
10882}
10883
10884template<> inline const tflite::UnpackOptions *Operator::builtin_options_as<tflite::UnpackOptions>() const {
10885 return builtin_options_as_UnpackOptions();
10886}
10887
10888template<> inline const tflite::FloorDivOptions *Operator::builtin_options_as<tflite::FloorDivOptions>() const {
10889 return builtin_options_as_FloorDivOptions();
10890}
10891
10892template<> inline const tflite::SquareOptions *Operator::builtin_options_as<tflite::SquareOptions>() const {
10893 return builtin_options_as_SquareOptions();
10894}
10895
10896template<> inline const tflite::ZerosLikeOptions *Operator::builtin_options_as<tflite::ZerosLikeOptions>() const {
10897 return builtin_options_as_ZerosLikeOptions();
10898}
10899
10900template<> inline const tflite::FillOptions *Operator::builtin_options_as<tflite::FillOptions>() const {
10901 return builtin_options_as_FillOptions();
10902}
10903
10904template<> inline const tflite::BidirectionalSequenceLSTMOptions *Operator::builtin_options_as<tflite::BidirectionalSequenceLSTMOptions>() const {
10905 return builtin_options_as_BidirectionalSequenceLSTMOptions();
10906}
10907
10908template<> inline const tflite::BidirectionalSequenceRNNOptions *Operator::builtin_options_as<tflite::BidirectionalSequenceRNNOptions>() const {
10909 return builtin_options_as_BidirectionalSequenceRNNOptions();
10910}
10911
10912template<> inline const tflite::UnidirectionalSequenceLSTMOptions *Operator::builtin_options_as<tflite::UnidirectionalSequenceLSTMOptions>() const {
10913 return builtin_options_as_UnidirectionalSequenceLSTMOptions();
10914}
10915
10916template<> inline const tflite::FloorModOptions *Operator::builtin_options_as<tflite::FloorModOptions>() const {
10917 return builtin_options_as_FloorModOptions();
10918}
10919
10920template<> inline const tflite::RangeOptions *Operator::builtin_options_as<tflite::RangeOptions>() const {
10921 return builtin_options_as_RangeOptions();
10922}
10923
10924template<> inline const tflite::ResizeNearestNeighborOptions *Operator::builtin_options_as<tflite::ResizeNearestNeighborOptions>() const {
10925 return builtin_options_as_ResizeNearestNeighborOptions();
10926}
10927
10928template<> inline const tflite::LeakyReluOptions *Operator::builtin_options_as<tflite::LeakyReluOptions>() const {
10929 return builtin_options_as_LeakyReluOptions();
10930}
10931
10932template<> inline const tflite::SquaredDifferenceOptions *Operator::builtin_options_as<tflite::SquaredDifferenceOptions>() const {
10933 return builtin_options_as_SquaredDifferenceOptions();
10934}
10935
10936template<> inline const tflite::MirrorPadOptions *Operator::builtin_options_as<tflite::MirrorPadOptions>() const {
10937 return builtin_options_as_MirrorPadOptions();
10938}
10939
10940template<> inline const tflite::AbsOptions *Operator::builtin_options_as<tflite::AbsOptions>() const {
10941 return builtin_options_as_AbsOptions();
10942}
10943
10944template<> inline const tflite::SplitVOptions *Operator::builtin_options_as<tflite::SplitVOptions>() const {
10945 return builtin_options_as_SplitVOptions();
10946}
10947
10948template<> inline const tflite::UniqueOptions *Operator::builtin_options_as<tflite::UniqueOptions>() const {
10949 return builtin_options_as_UniqueOptions();
10950}
10951
10952template<> inline const tflite::ReverseV2Options *Operator::builtin_options_as<tflite::ReverseV2Options>() const {
10953 return builtin_options_as_ReverseV2Options();
10954}
10955
10956template<> inline const tflite::AddNOptions *Operator::builtin_options_as<tflite::AddNOptions>() const {
10957 return builtin_options_as_AddNOptions();
10958}
10959
10960template<> inline const tflite::GatherNdOptions *Operator::builtin_options_as<tflite::GatherNdOptions>() const {
10961 return builtin_options_as_GatherNdOptions();
10962}
10963
10964template<> inline const tflite::CosOptions *Operator::builtin_options_as<tflite::CosOptions>() const {
10965 return builtin_options_as_CosOptions();
10966}
10967
10968template<> inline const tflite::WhereOptions *Operator::builtin_options_as<tflite::WhereOptions>() const {
10969 return builtin_options_as_WhereOptions();
10970}
10971
10972template<> inline const tflite::RankOptions *Operator::builtin_options_as<tflite::RankOptions>() const {
10973 return builtin_options_as_RankOptions();
10974}
10975
10976template<> inline const tflite::ReverseSequenceOptions *Operator::builtin_options_as<tflite::ReverseSequenceOptions>() const {
10977 return builtin_options_as_ReverseSequenceOptions();
10978}
10979
10980template<> inline const tflite::MatrixDiagOptions *Operator::builtin_options_as<tflite::MatrixDiagOptions>() const {
10981 return builtin_options_as_MatrixDiagOptions();
10982}
10983
10984template<> inline const tflite::QuantizeOptions *Operator::builtin_options_as<tflite::QuantizeOptions>() const {
10985 return builtin_options_as_QuantizeOptions();
10986}
10987
10988template<> inline const tflite::MatrixSetDiagOptions *Operator::builtin_options_as<tflite::MatrixSetDiagOptions>() const {
10989 return builtin_options_as_MatrixSetDiagOptions();
10990}
10991
10992template<> inline const tflite::HardSwishOptions *Operator::builtin_options_as<tflite::HardSwishOptions>() const {
10993 return builtin_options_as_HardSwishOptions();
10994}
10995
10996template<> inline const tflite::IfOptions *Operator::builtin_options_as<tflite::IfOptions>() const {
10997 return builtin_options_as_IfOptions();
10998}
10999
11000template<> inline const tflite::WhileOptions *Operator::builtin_options_as<tflite::WhileOptions>() const {
11001 return builtin_options_as_WhileOptions();
11002}
11003
11004template<> inline const tflite::DepthToSpaceOptions *Operator::builtin_options_as<tflite::DepthToSpaceOptions>() const {
11005 return builtin_options_as_DepthToSpaceOptions();
11006}
11007
11008template<> inline const tflite::NonMaxSuppressionV4Options *Operator::builtin_options_as<tflite::NonMaxSuppressionV4Options>() const {
11009 return builtin_options_as_NonMaxSuppressionV4Options();
11010}
11011
11012template<> inline const tflite::NonMaxSuppressionV5Options *Operator::builtin_options_as<tflite::NonMaxSuppressionV5Options>() const {
11013 return builtin_options_as_NonMaxSuppressionV5Options();
11014}
11015
11016template<> inline const tflite::ScatterNdOptions *Operator::builtin_options_as<tflite::ScatterNdOptions>() const {
11017 return builtin_options_as_ScatterNdOptions();
11018}
11019
11020template<> inline const tflite::SelectV2Options *Operator::builtin_options_as<tflite::SelectV2Options>() const {
11021 return builtin_options_as_SelectV2Options();
11022}
11023
11024template<> inline const tflite::DensifyOptions *Operator::builtin_options_as<tflite::DensifyOptions>() const {
11025 return builtin_options_as_DensifyOptions();
11026}
11027
11028template<> inline const tflite::SegmentSumOptions *Operator::builtin_options_as<tflite::SegmentSumOptions>() const {
11029 return builtin_options_as_SegmentSumOptions();
11030}
11031
11032template<> inline const tflite::BatchMatMulOptions *Operator::builtin_options_as<tflite::BatchMatMulOptions>() const {
11033 return builtin_options_as_BatchMatMulOptions();
11034}
11035
11036template<> inline const tflite::CumsumOptions *Operator::builtin_options_as<tflite::CumsumOptions>() const {
11037 return builtin_options_as_CumsumOptions();
11038}
11039
11040template<> inline const tflite::CallOnceOptions *Operator::builtin_options_as<tflite::CallOnceOptions>() const {
11041 return builtin_options_as_CallOnceOptions();
11042}
11043
11044template<> inline const tflite::BroadcastToOptions *Operator::builtin_options_as<tflite::BroadcastToOptions>() const {
11045 return builtin_options_as_BroadcastToOptions();
11046}
11047
11048template<> inline const tflite::Rfft2dOptions *Operator::builtin_options_as<tflite::Rfft2dOptions>() const {
11049 return builtin_options_as_Rfft2dOptions();
11050}
11051
11052template<> inline const tflite::Conv3DOptions *Operator::builtin_options_as<tflite::Conv3DOptions>() const {
11053 return builtin_options_as_Conv3DOptions();
11054}
11055
11056template<> inline const tflite::HashtableOptions *Operator::builtin_options_as<tflite::HashtableOptions>() const {
11057 return builtin_options_as_HashtableOptions();
11058}
11059
11060template<> inline const tflite::HashtableFindOptions *Operator::builtin_options_as<tflite::HashtableFindOptions>() const {
11061 return builtin_options_as_HashtableFindOptions();
11062}
11063
11064template<> inline const tflite::HashtableImportOptions *Operator::builtin_options_as<tflite::HashtableImportOptions>() const {
11065 return builtin_options_as_HashtableImportOptions();
11066}
11067
11068template<> inline const tflite::HashtableSizeOptions *Operator::builtin_options_as<tflite::HashtableSizeOptions>() const {
11069 return builtin_options_as_HashtableSizeOptions();
11070}
11071
11072struct OperatorBuilder {
11073 flatbuffers::FlatBufferBuilder &fbb_;
11074 flatbuffers::uoffset_t start_;
11075 void add_opcode_index(uint32_t opcode_index) {
11076 fbb_.AddElement<uint32_t>(Operator::VT_OPCODE_INDEX, opcode_index, 0);
11077 }
11078 void add_inputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs) {
11079 fbb_.AddOffset(Operator::VT_INPUTS, inputs);
11080 }
11081 void add_outputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs) {
11082 fbb_.AddOffset(Operator::VT_OUTPUTS, outputs);
11083 }
11084 void add_builtin_options_type(tflite::BuiltinOptions builtin_options_type) {
11085 fbb_.AddElement<uint8_t>(Operator::VT_BUILTIN_OPTIONS_TYPE, static_cast<uint8_t>(builtin_options_type), 0);
11086 }
11087 void add_builtin_options(flatbuffers::Offset<void> builtin_options) {
11088 fbb_.AddOffset(Operator::VT_BUILTIN_OPTIONS, builtin_options);
11089 }
11090 void add_custom_options(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom_options) {
11091 fbb_.AddOffset(Operator::VT_CUSTOM_OPTIONS, custom_options);
11092 }
11093 void add_custom_options_format(tflite::CustomOptionsFormat custom_options_format) {
11094 fbb_.AddElement<int8_t>(Operator::VT_CUSTOM_OPTIONS_FORMAT, static_cast<int8_t>(custom_options_format), 0);
11095 }
11096 void add_mutating_variable_inputs(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> mutating_variable_inputs) {
11097 fbb_.AddOffset(Operator::VT_MUTATING_VARIABLE_INPUTS, mutating_variable_inputs);
11098 }
11099 void add_intermediates(flatbuffers::Offset<flatbuffers::Vector<int32_t>> intermediates) {
11100 fbb_.AddOffset(Operator::VT_INTERMEDIATES, intermediates);
11101 }
11102 explicit OperatorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
11103 : fbb_(_fbb) {
11104 start_ = fbb_.StartTable();
11105 }
11106 OperatorBuilder &operator=(const OperatorBuilder &);
11107 flatbuffers::Offset<Operator> Finish() {
11108 const auto end = fbb_.EndTable(start_);
11109 auto o = flatbuffers::Offset<Operator>(end);
11110 return o;
11111 }
11112};
11113
11114inline flatbuffers::Offset<Operator> CreateOperator(
11115 flatbuffers::FlatBufferBuilder &_fbb,
11116 uint32_t opcode_index = 0,
11117 flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs = 0,
11118 flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs = 0,
11119 tflite::BuiltinOptions builtin_options_type = tflite::BuiltinOptions_NONE,
11120 flatbuffers::Offset<void> builtin_options = 0,
11121 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom_options = 0,
11122 tflite::CustomOptionsFormat custom_options_format = tflite::CustomOptionsFormat_FLEXBUFFERS,
11123 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> mutating_variable_inputs = 0,
11124 flatbuffers::Offset<flatbuffers::Vector<int32_t>> intermediates = 0) {
11125 OperatorBuilder builder_(_fbb);
11126 builder_.add_intermediates(intermediates);
11127 builder_.add_mutating_variable_inputs(mutating_variable_inputs);
11128 builder_.add_custom_options(custom_options);
11129 builder_.add_builtin_options(builtin_options);
11130 builder_.add_outputs(outputs);
11131 builder_.add_inputs(inputs);
11132 builder_.add_opcode_index(opcode_index);
11133 builder_.add_custom_options_format(custom_options_format);
11134 builder_.add_builtin_options_type(builtin_options_type);
11135 return builder_.Finish();
11136}
11137
11138inline flatbuffers::Offset<Operator> CreateOperatorDirect(
11139 flatbuffers::FlatBufferBuilder &_fbb,
11140 uint32_t opcode_index = 0,
11141 const std::vector<int32_t> *inputs = nullptr,
11142 const std::vector<int32_t> *outputs = nullptr,
11143 tflite::BuiltinOptions builtin_options_type = tflite::BuiltinOptions_NONE,
11144 flatbuffers::Offset<void> builtin_options = 0,
11145 const std::vector<uint8_t> *custom_options = nullptr,
11146 tflite::CustomOptionsFormat custom_options_format = tflite::CustomOptionsFormat_FLEXBUFFERS,
11147 const std::vector<uint8_t> *mutating_variable_inputs = nullptr,
11148 const std::vector<int32_t> *intermediates = nullptr) {
11149 auto inputs__ = inputs ? _fbb.CreateVector<int32_t>(*inputs) : 0;
11150 auto outputs__ = outputs ? _fbb.CreateVector<int32_t>(*outputs) : 0;
11151 auto custom_options__ = custom_options ? _fbb.CreateVector<uint8_t>(*custom_options) : 0;
11152 auto mutating_variable_inputs__ = mutating_variable_inputs ? _fbb.CreateVector<uint8_t>(*mutating_variable_inputs) : 0;
11153 auto intermediates__ = intermediates ? _fbb.CreateVector<int32_t>(*intermediates) : 0;
11154 return tflite::CreateOperator(
11155 _fbb,
11156 opcode_index,
11157 inputs__,
11158 outputs__,
11159 builtin_options_type,
11160 builtin_options,
11161 custom_options__,
11162 custom_options_format,
11163 mutating_variable_inputs__,
11164 intermediates__);
11165}
11166
11167flatbuffers::Offset<Operator> CreateOperator(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11168
11169struct SubGraphT : public flatbuffers::NativeTable {
11170 typedef SubGraph TableType;
11171 std::vector<std::unique_ptr<tflite::TensorT>> tensors;
11172 std::vector<int32_t> inputs;
11173 std::vector<int32_t> outputs;
11174 std::vector<std::unique_ptr<tflite::OperatorT>> operators;
11175 std::string name;
11176 SubGraphT() {
11177 }
11178};
11179
11180struct SubGraph FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11181 typedef SubGraphT NativeTableType;
11182 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
11183 VT_TENSORS = 4,
11184 VT_INPUTS = 6,
11185 VT_OUTPUTS = 8,
11186 VT_OPERATORS = 10,
11187 VT_NAME = 12
11188 };
11189 const flatbuffers::Vector<flatbuffers::Offset<tflite::Tensor>> *tensors() const {
11190 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::Tensor>> *>(VT_TENSORS);
11191 }
11192 const flatbuffers::Vector<int32_t> *inputs() const {
11193 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_INPUTS);
11194 }
11195 const flatbuffers::Vector<int32_t> *outputs() const {
11196 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OUTPUTS);
11197 }
11198 const flatbuffers::Vector<flatbuffers::Offset<tflite::Operator>> *operators() const {
11199 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::Operator>> *>(VT_OPERATORS);
11200 }
11201 const flatbuffers::String *name() const {
11202 return GetPointer<const flatbuffers::String *>(VT_NAME);
11203 }
11204 bool Verify(flatbuffers::Verifier &verifier) const {
11205 return VerifyTableStart(verifier) &&
11206 VerifyOffset(verifier, VT_TENSORS) &&
11207 verifier.VerifyVector(tensors()) &&
11208 verifier.VerifyVectorOfTables(tensors()) &&
11209 VerifyOffset(verifier, VT_INPUTS) &&
11210 verifier.VerifyVector(inputs()) &&
11211 VerifyOffset(verifier, VT_OUTPUTS) &&
11212 verifier.VerifyVector(outputs()) &&
11213 VerifyOffset(verifier, VT_OPERATORS) &&
11214 verifier.VerifyVector(operators()) &&
11215 verifier.VerifyVectorOfTables(operators()) &&
11216 VerifyOffset(verifier, VT_NAME) &&
11217 verifier.VerifyString(name()) &&
11218 verifier.EndTable();
11219 }
11220 SubGraphT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11221 void UnPackTo(SubGraphT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11222 static flatbuffers::Offset<SubGraph> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11223};
11224
11225struct SubGraphBuilder {
11226 flatbuffers::FlatBufferBuilder &fbb_;
11227 flatbuffers::uoffset_t start_;
11228 void add_tensors(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Tensor>>> tensors) {
11229 fbb_.AddOffset(SubGraph::VT_TENSORS, tensors);
11230 }
11231 void add_inputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs) {
11232 fbb_.AddOffset(SubGraph::VT_INPUTS, inputs);
11233 }
11234 void add_outputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs) {
11235 fbb_.AddOffset(SubGraph::VT_OUTPUTS, outputs);
11236 }
11237 void add_operators(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Operator>>> operators) {
11238 fbb_.AddOffset(SubGraph::VT_OPERATORS, operators);
11239 }
11240 void add_name(flatbuffers::Offset<flatbuffers::String> name) {
11241 fbb_.AddOffset(SubGraph::VT_NAME, name);
11242 }
11243 explicit SubGraphBuilder(flatbuffers::FlatBufferBuilder &_fbb)
11244 : fbb_(_fbb) {
11245 start_ = fbb_.StartTable();
11246 }
11247 SubGraphBuilder &operator=(const SubGraphBuilder &);
11248 flatbuffers::Offset<SubGraph> Finish() {
11249 const auto end = fbb_.EndTable(start_);
11250 auto o = flatbuffers::Offset<SubGraph>(end);
11251 return o;
11252 }
11253};
11254
11255inline flatbuffers::Offset<SubGraph> CreateSubGraph(
11256 flatbuffers::FlatBufferBuilder &_fbb,
11257 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Tensor>>> tensors = 0,
11258 flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs = 0,
11259 flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs = 0,
11260 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Operator>>> operators = 0,
11261 flatbuffers::Offset<flatbuffers::String> name = 0) {
11262 SubGraphBuilder builder_(_fbb);
11263 builder_.add_name(name);
11264 builder_.add_operators(operators);
11265 builder_.add_outputs(outputs);
11266 builder_.add_inputs(inputs);
11267 builder_.add_tensors(tensors);
11268 return builder_.Finish();
11269}
11270
11271inline flatbuffers::Offset<SubGraph> CreateSubGraphDirect(
11272 flatbuffers::FlatBufferBuilder &_fbb,
11273 const std::vector<flatbuffers::Offset<tflite::Tensor>> *tensors = nullptr,
11274 const std::vector<int32_t> *inputs = nullptr,
11275 const std::vector<int32_t> *outputs = nullptr,
11276 const std::vector<flatbuffers::Offset<tflite::Operator>> *operators = nullptr,
11277 const char *name = nullptr) {
11278 auto tensors__ = tensors ? _fbb.CreateVector<flatbuffers::Offset<tflite::Tensor>>(*tensors) : 0;
11279 auto inputs__ = inputs ? _fbb.CreateVector<int32_t>(*inputs) : 0;
11280 auto outputs__ = outputs ? _fbb.CreateVector<int32_t>(*outputs) : 0;
11281 auto operators__ = operators ? _fbb.CreateVector<flatbuffers::Offset<tflite::Operator>>(*operators) : 0;
11282 auto name__ = name ? _fbb.CreateString(name) : 0;
11283 return tflite::CreateSubGraph(
11284 _fbb,
11285 tensors__,
11286 inputs__,
11287 outputs__,
11288 operators__,
11289 name__);
11290}
11291
11292flatbuffers::Offset<SubGraph> CreateSubGraph(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11293
11294struct BufferT : public flatbuffers::NativeTable {
11295 typedef Buffer TableType;
11296 std::vector<uint8_t> data;
11297 BufferT() {
11298 }
11299};
11300
11301struct Buffer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11302 typedef BufferT NativeTableType;
11303 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
11304 VT_DATA = 4
11305 };
11306 const flatbuffers::Vector<uint8_t> *data() const {
11307 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_DATA);
11308 }
11309 bool Verify(flatbuffers::Verifier &verifier) const {
11310 return VerifyTableStart(verifier) &&
11311 VerifyOffset(verifier, VT_DATA) &&
11312 verifier.VerifyVector(data()) &&
11313 verifier.EndTable();
11314 }
11315 BufferT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11316 void UnPackTo(BufferT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11317 static flatbuffers::Offset<Buffer> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BufferT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11318};
11319
11320struct BufferBuilder {
11321 flatbuffers::FlatBufferBuilder &fbb_;
11322 flatbuffers::uoffset_t start_;
11323 void add_data(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data) {
11324 fbb_.AddOffset(Buffer::VT_DATA, data);
11325 }
11326 explicit BufferBuilder(flatbuffers::FlatBufferBuilder &_fbb)
11327 : fbb_(_fbb) {
11328 start_ = fbb_.StartTable();
11329 }
11330 BufferBuilder &operator=(const BufferBuilder &);
11331 flatbuffers::Offset<Buffer> Finish() {
11332 const auto end = fbb_.EndTable(start_);
11333 auto o = flatbuffers::Offset<Buffer>(end);
11334 return o;
11335 }
11336};
11337
11338inline flatbuffers::Offset<Buffer> CreateBuffer(
11339 flatbuffers::FlatBufferBuilder &_fbb,
11340 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data = 0) {
11341 BufferBuilder builder_(_fbb);
11342 builder_.add_data(data);
11343 return builder_.Finish();
11344}
11345
11346inline flatbuffers::Offset<Buffer> CreateBufferDirect(
11347 flatbuffers::FlatBufferBuilder &_fbb,
11348 const std::vector<uint8_t> *data = nullptr) {
11349 if (data) { _fbb.ForceVectorAlignment(data->size(), sizeof(uint8_t), 16); }
11350 auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
11351 return tflite::CreateBuffer(
11352 _fbb,
11353 data__);
11354}
11355
11356flatbuffers::Offset<Buffer> CreateBuffer(flatbuffers::FlatBufferBuilder &_fbb, const BufferT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11357
11358struct MetadataT : public flatbuffers::NativeTable {
11359 typedef Metadata TableType;
11360 std::string name;
11361 uint32_t buffer;
11362 MetadataT()
11363 : buffer(0) {
11364 }
11365};
11366
11367struct Metadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11368 typedef MetadataT NativeTableType;
11369 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
11370 VT_NAME = 4,
11371 VT_BUFFER = 6
11372 };
11373 const flatbuffers::String *name() const {
11374 return GetPointer<const flatbuffers::String *>(VT_NAME);
11375 }
11376 uint32_t buffer() const {
11377 return GetField<uint32_t>(VT_BUFFER, 0);
11378 }
11379 bool Verify(flatbuffers::Verifier &verifier) const {
11380 return VerifyTableStart(verifier) &&
11381 VerifyOffset(verifier, VT_NAME) &&
11382 verifier.VerifyString(name()) &&
11383 VerifyField<uint32_t>(verifier, VT_BUFFER) &&
11384 verifier.EndTable();
11385 }
11386 MetadataT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11387 void UnPackTo(MetadataT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11388 static flatbuffers::Offset<Metadata> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11389};
11390
11391struct MetadataBuilder {
11392 flatbuffers::FlatBufferBuilder &fbb_;
11393 flatbuffers::uoffset_t start_;
11394 void add_name(flatbuffers::Offset<flatbuffers::String> name) {
11395 fbb_.AddOffset(Metadata::VT_NAME, name);
11396 }
11397 void add_buffer(uint32_t buffer) {
11398 fbb_.AddElement<uint32_t>(Metadata::VT_BUFFER, buffer, 0);
11399 }
11400 explicit MetadataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
11401 : fbb_(_fbb) {
11402 start_ = fbb_.StartTable();
11403 }
11404 MetadataBuilder &operator=(const MetadataBuilder &);
11405 flatbuffers::Offset<Metadata> Finish() {
11406 const auto end = fbb_.EndTable(start_);
11407 auto o = flatbuffers::Offset<Metadata>(end);
11408 return o;
11409 }
11410};
11411
11412inline flatbuffers::Offset<Metadata> CreateMetadata(
11413 flatbuffers::FlatBufferBuilder &_fbb,
11414 flatbuffers::Offset<flatbuffers::String> name = 0,
11415 uint32_t buffer = 0) {
11416 MetadataBuilder builder_(_fbb);
11417 builder_.add_buffer(buffer);
11418 builder_.add_name(name);
11419 return builder_.Finish();
11420}
11421
11422inline flatbuffers::Offset<Metadata> CreateMetadataDirect(
11423 flatbuffers::FlatBufferBuilder &_fbb,
11424 const char *name = nullptr,
11425 uint32_t buffer = 0) {
11426 auto name__ = name ? _fbb.CreateString(name) : 0;
11427 return tflite::CreateMetadata(
11428 _fbb,
11429 name__,
11430 buffer);
11431}
11432
11433flatbuffers::Offset<Metadata> CreateMetadata(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11434
11435struct TensorMapT : public flatbuffers::NativeTable {
11436 typedef TensorMap TableType;
11437 std::string name;
11438 uint32_t tensor_index;
11439 TensorMapT()
11440 : tensor_index(0) {
11441 }
11442};
11443
11444struct TensorMap FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11445 typedef TensorMapT NativeTableType;
11446 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
11447 VT_NAME = 4,
11448 VT_TENSOR_INDEX = 6
11449 };
11450 const flatbuffers::String *name() const {
11451 return GetPointer<const flatbuffers::String *>(VT_NAME);
11452 }
11453 uint32_t tensor_index() const {
11454 return GetField<uint32_t>(VT_TENSOR_INDEX, 0);
11455 }
11456 bool Verify(flatbuffers::Verifier &verifier) const {
11457 return VerifyTableStart(verifier) &&
11458 VerifyOffset(verifier, VT_NAME) &&
11459 verifier.VerifyString(name()) &&
11460 VerifyField<uint32_t>(verifier, VT_TENSOR_INDEX) &&
11461 verifier.EndTable();
11462 }
11463 TensorMapT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11464 void UnPackTo(TensorMapT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11465 static flatbuffers::Offset<TensorMap> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorMapT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11466};
11467
11468struct TensorMapBuilder {
11469 flatbuffers::FlatBufferBuilder &fbb_;
11470 flatbuffers::uoffset_t start_;
11471 void add_name(flatbuffers::Offset<flatbuffers::String> name) {
11472 fbb_.AddOffset(TensorMap::VT_NAME, name);
11473 }
11474 void add_tensor_index(uint32_t tensor_index) {
11475 fbb_.AddElement<uint32_t>(TensorMap::VT_TENSOR_INDEX, tensor_index, 0);
11476 }
11477 explicit TensorMapBuilder(flatbuffers::FlatBufferBuilder &_fbb)
11478 : fbb_(_fbb) {
11479 start_ = fbb_.StartTable();
11480 }
11481 TensorMapBuilder &operator=(const TensorMapBuilder &);
11482 flatbuffers::Offset<TensorMap> Finish() {
11483 const auto end = fbb_.EndTable(start_);
11484 auto o = flatbuffers::Offset<TensorMap>(end);
11485 return o;
11486 }
11487};
11488
11489inline flatbuffers::Offset<TensorMap> CreateTensorMap(
11490 flatbuffers::FlatBufferBuilder &_fbb,
11491 flatbuffers::Offset<flatbuffers::String> name = 0,
11492 uint32_t tensor_index = 0) {
11493 TensorMapBuilder builder_(_fbb);
11494 builder_.add_tensor_index(tensor_index);
11495 builder_.add_name(name);
11496 return builder_.Finish();
11497}
11498
11499inline flatbuffers::Offset<TensorMap> CreateTensorMapDirect(
11500 flatbuffers::FlatBufferBuilder &_fbb,
11501 const char *name = nullptr,
11502 uint32_t tensor_index = 0) {
11503 auto name__ = name ? _fbb.CreateString(name) : 0;
11504 return tflite::CreateTensorMap(
11505 _fbb,
11506 name__,
11507 tensor_index);
11508}
11509
11510flatbuffers::Offset<TensorMap> CreateTensorMap(flatbuffers::FlatBufferBuilder &_fbb, const TensorMapT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11511
11512struct SignatureDefT : public flatbuffers::NativeTable {
11513 typedef SignatureDef TableType;
11514 std::vector<std::unique_ptr<tflite::TensorMapT>> inputs;
11515 std::vector<std::unique_ptr<tflite::TensorMapT>> outputs;
11516 std::string method_name;
11517 std::string key;
11518 SignatureDefT() {
11519 }
11520};
11521
11522struct SignatureDef FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11523 typedef SignatureDefT NativeTableType;
11524 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
11525 VT_INPUTS = 4,
11526 VT_OUTPUTS = 6,
11527 VT_METHOD_NAME = 8,
11528 VT_KEY = 10
11529 };
11530 const flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>> *inputs() const {
11531 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>> *>(VT_INPUTS);
11532 }
11533 const flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>> *outputs() const {
11534 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>> *>(VT_OUTPUTS);
11535 }
11536 const flatbuffers::String *method_name() const {
11537 return GetPointer<const flatbuffers::String *>(VT_METHOD_NAME);
11538 }
11539 const flatbuffers::String *key() const {
11540 return GetPointer<const flatbuffers::String *>(VT_KEY);
11541 }
11542 bool Verify(flatbuffers::Verifier &verifier) const {
11543 return VerifyTableStart(verifier) &&
11544 VerifyOffset(verifier, VT_INPUTS) &&
11545 verifier.VerifyVector(inputs()) &&
11546 verifier.VerifyVectorOfTables(inputs()) &&
11547 VerifyOffset(verifier, VT_OUTPUTS) &&
11548 verifier.VerifyVector(outputs()) &&
11549 verifier.VerifyVectorOfTables(outputs()) &&
11550 VerifyOffset(verifier, VT_METHOD_NAME) &&
11551 verifier.VerifyString(method_name()) &&
11552 VerifyOffset(verifier, VT_KEY) &&
11553 verifier.VerifyString(key()) &&
11554 verifier.EndTable();
11555 }
11556 SignatureDefT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11557 void UnPackTo(SignatureDefT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11558 static flatbuffers::Offset<SignatureDef> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SignatureDefT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11559};
11560
11561struct SignatureDefBuilder {
11562 flatbuffers::FlatBufferBuilder &fbb_;
11563 flatbuffers::uoffset_t start_;
11564 void add_inputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>>> inputs) {
11565 fbb_.AddOffset(SignatureDef::VT_INPUTS, inputs);
11566 }
11567 void add_outputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>>> outputs) {
11568 fbb_.AddOffset(SignatureDef::VT_OUTPUTS, outputs);
11569 }
11570 void add_method_name(flatbuffers::Offset<flatbuffers::String> method_name) {
11571 fbb_.AddOffset(SignatureDef::VT_METHOD_NAME, method_name);
11572 }
11573 void add_key(flatbuffers::Offset<flatbuffers::String> key) {
11574 fbb_.AddOffset(SignatureDef::VT_KEY, key);
11575 }
11576 explicit SignatureDefBuilder(flatbuffers::FlatBufferBuilder &_fbb)
11577 : fbb_(_fbb) {
11578 start_ = fbb_.StartTable();
11579 }
11580 SignatureDefBuilder &operator=(const SignatureDefBuilder &);
11581 flatbuffers::Offset<SignatureDef> Finish() {
11582 const auto end = fbb_.EndTable(start_);
11583 auto o = flatbuffers::Offset<SignatureDef>(end);
11584 return o;
11585 }
11586};
11587
11588inline flatbuffers::Offset<SignatureDef> CreateSignatureDef(
11589 flatbuffers::FlatBufferBuilder &_fbb,
11590 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>>> inputs = 0,
11591 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>>> outputs = 0,
11592 flatbuffers::Offset<flatbuffers::String> method_name = 0,
11593 flatbuffers::Offset<flatbuffers::String> key = 0) {
11594 SignatureDefBuilder builder_(_fbb);
11595 builder_.add_key(key);
11596 builder_.add_method_name(method_name);
11597 builder_.add_outputs(outputs);
11598 builder_.add_inputs(inputs);
11599 return builder_.Finish();
11600}
11601
11602inline flatbuffers::Offset<SignatureDef> CreateSignatureDefDirect(
11603 flatbuffers::FlatBufferBuilder &_fbb,
11604 const std::vector<flatbuffers::Offset<tflite::TensorMap>> *inputs = nullptr,
11605 const std::vector<flatbuffers::Offset<tflite::TensorMap>> *outputs = nullptr,
11606 const char *method_name = nullptr,
11607 const char *key = nullptr) {
11608 auto inputs__ = inputs ? _fbb.CreateVector<flatbuffers::Offset<tflite::TensorMap>>(*inputs) : 0;
11609 auto outputs__ = outputs ? _fbb.CreateVector<flatbuffers::Offset<tflite::TensorMap>>(*outputs) : 0;
11610 auto method_name__ = method_name ? _fbb.CreateString(method_name) : 0;
11611 auto key__ = key ? _fbb.CreateString(key) : 0;
11612 return tflite::CreateSignatureDef(
11613 _fbb,
11614 inputs__,
11615 outputs__,
11616 method_name__,
11617 key__);
11618}
11619
11620flatbuffers::Offset<SignatureDef> CreateSignatureDef(flatbuffers::FlatBufferBuilder &_fbb, const SignatureDefT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11621
11622struct ModelT : public flatbuffers::NativeTable {
11623 typedef Model TableType;
11624 uint32_t version;
11625 std::vector<std::unique_ptr<tflite::OperatorCodeT>> operator_codes;
11626 std::vector<std::unique_ptr<tflite::SubGraphT>> subgraphs;
11627 std::string description;
11628 std::vector<std::unique_ptr<tflite::BufferT>> buffers;
11629 std::vector<int32_t> metadata_buffer;
11630 std::vector<std::unique_ptr<tflite::MetadataT>> metadata;
11631 std::vector<std::unique_ptr<tflite::SignatureDefT>> signature_defs;
11632 ModelT()
11633 : version(0) {
11634 }
11635};
11636
11637struct Model FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11638 typedef ModelT NativeTableType;
11639 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
11640 VT_VERSION = 4,
11641 VT_OPERATOR_CODES = 6,
11642 VT_SUBGRAPHS = 8,
11643 VT_DESCRIPTION = 10,
11644 VT_BUFFERS = 12,
11645 VT_METADATA_BUFFER = 14,
11646 VT_METADATA = 16,
11647 VT_SIGNATURE_DEFS = 18
11648 };
11649 uint32_t version() const {
11650 return GetField<uint32_t>(VT_VERSION, 0);
11651 }
11652 const flatbuffers::Vector<flatbuffers::Offset<tflite::OperatorCode>> *operator_codes() const {
11653 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::OperatorCode>> *>(VT_OPERATOR_CODES);
11654 }
11655 const flatbuffers::Vector<flatbuffers::Offset<tflite::SubGraph>> *subgraphs() const {
11656 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::SubGraph>> *>(VT_SUBGRAPHS);
11657 }
11658 const flatbuffers::String *description() const {
11659 return GetPointer<const flatbuffers::String *>(VT_DESCRIPTION);
11660 }
11661 const flatbuffers::Vector<flatbuffers::Offset<tflite::Buffer>> *buffers() const {
11662 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::Buffer>> *>(VT_BUFFERS);
11663 }
11664 const flatbuffers::Vector<int32_t> *metadata_buffer() const {
11665 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_METADATA_BUFFER);
11666 }
11667 const flatbuffers::Vector<flatbuffers::Offset<tflite::Metadata>> *metadata() const {
11668 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::Metadata>> *>(VT_METADATA);
11669 }
11670 const flatbuffers::Vector<flatbuffers::Offset<tflite::SignatureDef>> *signature_defs() const {
11671 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::SignatureDef>> *>(VT_SIGNATURE_DEFS);
11672 }
11673 bool Verify(flatbuffers::Verifier &verifier) const {
11674 return VerifyTableStart(verifier) &&
11675 VerifyField<uint32_t>(verifier, VT_VERSION) &&
11676 VerifyOffset(verifier, VT_OPERATOR_CODES) &&
11677 verifier.VerifyVector(operator_codes()) &&
11678 verifier.VerifyVectorOfTables(operator_codes()) &&
11679 VerifyOffset(verifier, VT_SUBGRAPHS) &&
11680 verifier.VerifyVector(subgraphs()) &&
11681 verifier.VerifyVectorOfTables(subgraphs()) &&
11682 VerifyOffset(verifier, VT_DESCRIPTION) &&
11683 verifier.VerifyString(description()) &&
11684 VerifyOffset(verifier, VT_BUFFERS) &&
11685 verifier.VerifyVector(buffers()) &&
11686 verifier.VerifyVectorOfTables(buffers()) &&
11687 VerifyOffset(verifier, VT_METADATA_BUFFER) &&
11688 verifier.VerifyVector(metadata_buffer()) &&
11689 VerifyOffset(verifier, VT_METADATA) &&
11690 verifier.VerifyVector(metadata()) &&
11691 verifier.VerifyVectorOfTables(metadata()) &&
11692 VerifyOffset(verifier, VT_SIGNATURE_DEFS) &&
11693 verifier.VerifyVector(signature_defs()) &&
11694 verifier.VerifyVectorOfTables(signature_defs()) &&
11695 verifier.EndTable();
11696 }
11697 ModelT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11698 void UnPackTo(ModelT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11699 static flatbuffers::Offset<Model> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ModelT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11700};
11701
11702struct ModelBuilder {
11703 flatbuffers::FlatBufferBuilder &fbb_;
11704 flatbuffers::uoffset_t start_;
11705 void add_version(uint32_t version) {
11706 fbb_.AddElement<uint32_t>(Model::VT_VERSION, version, 0);
11707 }
11708 void add_operator_codes(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::OperatorCode>>> operator_codes) {
11709 fbb_.AddOffset(Model::VT_OPERATOR_CODES, operator_codes);
11710 }
11711 void add_subgraphs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::SubGraph>>> subgraphs) {
11712 fbb_.AddOffset(Model::VT_SUBGRAPHS, subgraphs);
11713 }
11714 void add_description(flatbuffers::Offset<flatbuffers::String> description) {
11715 fbb_.AddOffset(Model::VT_DESCRIPTION, description);
11716 }
11717 void add_buffers(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Buffer>>> buffers) {
11718 fbb_.AddOffset(Model::VT_BUFFERS, buffers);
11719 }
11720 void add_metadata_buffer(flatbuffers::Offset<flatbuffers::Vector<int32_t>> metadata_buffer) {
11721 fbb_.AddOffset(Model::VT_METADATA_BUFFER, metadata_buffer);
11722 }
11723 void add_metadata(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Metadata>>> metadata) {
11724 fbb_.AddOffset(Model::VT_METADATA, metadata);
11725 }
11726 void add_signature_defs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::SignatureDef>>> signature_defs) {
11727 fbb_.AddOffset(Model::VT_SIGNATURE_DEFS, signature_defs);
11728 }
11729 explicit ModelBuilder(flatbuffers::FlatBufferBuilder &_fbb)
11730 : fbb_(_fbb) {
11731 start_ = fbb_.StartTable();
11732 }
11733 ModelBuilder &operator=(const ModelBuilder &);
11734 flatbuffers::Offset<Model> Finish() {
11735 const auto end = fbb_.EndTable(start_);
11736 auto o = flatbuffers::Offset<Model>(end);
11737 return o;
11738 }
11739};
11740
11741inline flatbuffers::Offset<Model> CreateModel(
11742 flatbuffers::FlatBufferBuilder &_fbb,
11743 uint32_t version = 0,
11744 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::OperatorCode>>> operator_codes = 0,
11745 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::SubGraph>>> subgraphs = 0,
11746 flatbuffers::Offset<flatbuffers::String> description = 0,
11747 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Buffer>>> buffers = 0,
11748 flatbuffers::Offset<flatbuffers::Vector<int32_t>> metadata_buffer = 0,
11749 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Metadata>>> metadata = 0,
11750 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::SignatureDef>>> signature_defs = 0) {
11751 ModelBuilder builder_(_fbb);
11752 builder_.add_signature_defs(signature_defs);
11753 builder_.add_metadata(metadata);
11754 builder_.add_metadata_buffer(metadata_buffer);
11755 builder_.add_buffers(buffers);
11756 builder_.add_description(description);
11757 builder_.add_subgraphs(subgraphs);
11758 builder_.add_operator_codes(operator_codes);
11759 builder_.add_version(version);
11760 return builder_.Finish();
11761}
11762
11763inline flatbuffers::Offset<Model> CreateModelDirect(
11764 flatbuffers::FlatBufferBuilder &_fbb,
11765 uint32_t version = 0,
11766 const std::vector<flatbuffers::Offset<tflite::OperatorCode>> *operator_codes = nullptr,
11767 const std::vector<flatbuffers::Offset<tflite::SubGraph>> *subgraphs = nullptr,
11768 const char *description = nullptr,
11769 const std::vector<flatbuffers::Offset<tflite::Buffer>> *buffers = nullptr,
11770 const std::vector<int32_t> *metadata_buffer = nullptr,
11771 const std::vector<flatbuffers::Offset<tflite::Metadata>> *metadata = nullptr,
11772 const std::vector<flatbuffers::Offset<tflite::SignatureDef>> *signature_defs = nullptr) {
11773 auto operator_codes__ = operator_codes ? _fbb.CreateVector<flatbuffers::Offset<tflite::OperatorCode>>(*operator_codes) : 0;
11774 auto subgraphs__ = subgraphs ? _fbb.CreateVector<flatbuffers::Offset<tflite::SubGraph>>(*subgraphs) : 0;
11775 auto description__ = description ? _fbb.CreateString(description) : 0;
11776 auto buffers__ = buffers ? _fbb.CreateVector<flatbuffers::Offset<tflite::Buffer>>(*buffers) : 0;
11777 auto metadata_buffer__ = metadata_buffer ? _fbb.CreateVector<int32_t>(*metadata_buffer) : 0;
11778 auto metadata__ = metadata ? _fbb.CreateVector<flatbuffers::Offset<tflite::Metadata>>(*metadata) : 0;
11779 auto signature_defs__ = signature_defs ? _fbb.CreateVector<flatbuffers::Offset<tflite::SignatureDef>>(*signature_defs) : 0;
11780 return tflite::CreateModel(
11781 _fbb,
11782 version,
11783 operator_codes__,
11784 subgraphs__,
11785 description__,
11786 buffers__,
11787 metadata_buffer__,
11788 metadata__,
11789 signature_defs__);
11790}
11791
11792flatbuffers::Offset<Model> CreateModel(flatbuffers::FlatBufferBuilder &_fbb, const ModelT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11793
11794inline CustomQuantizationT *CustomQuantization::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
11795 auto _o = new CustomQuantizationT();
11796 UnPackTo(_o, _resolver);
11797 return _o;
11798}
11799
11800inline void CustomQuantization::UnPackTo(CustomQuantizationT *_o, const flatbuffers::resolver_function_t *_resolver) const {
11801 (void)_o;
11802 (void)_resolver;
11803 { auto _e = custom(); if (_e) { _o->custom.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->custom.begin()); } }
11804}
11805
11806inline flatbuffers::Offset<CustomQuantization> CustomQuantization::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
11807 return CreateCustomQuantization(_fbb, _o, _rehasher);
11808}
11809
11810inline flatbuffers::Offset<CustomQuantization> CreateCustomQuantization(flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
11811 (void)_rehasher;
11812 (void)_o;
11813 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const CustomQuantizationT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
11814 _fbb.ForceVectorAlignment(_o->custom.size(), sizeof(uint8_t), 16);
11815 auto _custom = _o->custom.size() ? _fbb.CreateVector(_o->custom) : 0;
11816 return tflite::CreateCustomQuantization(
11817 _fbb,
11818 _custom);
11819}
11820
11821inline QuantizationParametersT *QuantizationParameters::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
11822 auto _o = new QuantizationParametersT();
11823 UnPackTo(_o, _resolver);
11824 return _o;
11825}
11826
11827inline void QuantizationParameters::UnPackTo(QuantizationParametersT *_o, const flatbuffers::resolver_function_t *_resolver) const {
11828 (void)_o;
11829 (void)_resolver;
11830 { auto _e = min(); if (_e) { _o->min.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->min[_i] = _e->Get(_i); } } }
11831 { auto _e = max(); if (_e) { _o->max.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->max[_i] = _e->Get(_i); } } }
11832 { auto _e = scale(); if (_e) { _o->scale.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->scale[_i] = _e->Get(_i); } } }
11833 { auto _e = zero_point(); if (_e) { _o->zero_point.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->zero_point[_i] = _e->Get(_i); } } }
11834 { auto _e = details_type(); _o->details.type = _e; }
11835 { auto _e = details(); if (_e) _o->details.value = tflite::QuantizationDetailsUnion::UnPack(_e, details_type(), _resolver); }
11836 { auto _e = quantized_dimension(); _o->quantized_dimension = _e; }
11837}
11838
11839inline flatbuffers::Offset<QuantizationParameters> QuantizationParameters::Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
11840 return CreateQuantizationParameters(_fbb, _o, _rehasher);
11841}
11842
11843inline flatbuffers::Offset<QuantizationParameters> CreateQuantizationParameters(flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
11844 (void)_rehasher;
11845 (void)_o;
11846 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const QuantizationParametersT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
11847 auto _min = _o->min.size() ? _fbb.CreateVector(_o->min) : 0;
11848 auto _max = _o->max.size() ? _fbb.CreateVector(_o->max) : 0;
11849 auto _scale = _o->scale.size() ? _fbb.CreateVector(_o->scale) : 0;
11850 auto _zero_point = _o->zero_point.size() ? _fbb.CreateVector(_o->zero_point) : 0;
11851 auto _details_type = _o->details.type;
11852 auto _details = _o->details.Pack(_fbb);
11853 auto _quantized_dimension = _o->quantized_dimension;
11854 return tflite::CreateQuantizationParameters(
11855 _fbb,
11856 _min,
11857 _max,
11858 _scale,
11859 _zero_point,
11860 _details_type,
11861 _details,
11862 _quantized_dimension);
11863}
11864
11865inline Int32VectorT *Int32Vector::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
11866 auto _o = new Int32VectorT();
11867 UnPackTo(_o, _resolver);
11868 return _o;
11869}
11870
11871inline void Int32Vector::UnPackTo(Int32VectorT *_o, const flatbuffers::resolver_function_t *_resolver) const {
11872 (void)_o;
11873 (void)_resolver;
11874 { auto _e = values(); if (_e) { _o->values.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->values[_i] = _e->Get(_i); } } }
11875}
11876
11877inline flatbuffers::Offset<Int32Vector> Int32Vector::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Int32VectorT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
11878 return CreateInt32Vector(_fbb, _o, _rehasher);
11879}
11880
11881inline flatbuffers::Offset<Int32Vector> CreateInt32Vector(flatbuffers::FlatBufferBuilder &_fbb, const Int32VectorT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
11882 (void)_rehasher;
11883 (void)_o;
11884 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const Int32VectorT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
11885 auto _values = _o->values.size() ? _fbb.CreateVector(_o->values) : 0;
11886 return tflite::CreateInt32Vector(
11887 _fbb,
11888 _values);
11889}
11890
11891inline Uint16VectorT *Uint16Vector::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
11892 auto _o = new Uint16VectorT();
11893 UnPackTo(_o, _resolver);
11894 return _o;
11895}
11896
11897inline void Uint16Vector::UnPackTo(Uint16VectorT *_o, const flatbuffers::resolver_function_t *_resolver) const {
11898 (void)_o;
11899 (void)_resolver;
11900 { auto _e = values(); if (_e) { _o->values.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->values[_i] = _e->Get(_i); } } }
11901}
11902
11903inline flatbuffers::Offset<Uint16Vector> Uint16Vector::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Uint16VectorT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
11904 return CreateUint16Vector(_fbb, _o, _rehasher);
11905}
11906
11907inline flatbuffers::Offset<Uint16Vector> CreateUint16Vector(flatbuffers::FlatBufferBuilder &_fbb, const Uint16VectorT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
11908 (void)_rehasher;
11909 (void)_o;
11910 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const Uint16VectorT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
11911 _fbb.ForceVectorAlignment(_o->values.size(), sizeof(uint16_t), 4);
11912 auto _values = _o->values.size() ? _fbb.CreateVector(_o->values) : 0;
11913 return tflite::CreateUint16Vector(
11914 _fbb,
11915 _values);
11916}
11917
11918inline Uint8VectorT *Uint8Vector::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
11919 auto _o = new Uint8VectorT();
11920 UnPackTo(_o, _resolver);
11921 return _o;
11922}
11923
11924inline void Uint8Vector::UnPackTo(Uint8VectorT *_o, const flatbuffers::resolver_function_t *_resolver) const {
11925 (void)_o;
11926 (void)_resolver;
11927 { auto _e = values(); if (_e) { _o->values.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->values.begin()); } }
11928}
11929
11930inline flatbuffers::Offset<Uint8Vector> Uint8Vector::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Uint8VectorT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
11931 return CreateUint8Vector(_fbb, _o, _rehasher);
11932}
11933
11934inline flatbuffers::Offset<Uint8Vector> CreateUint8Vector(flatbuffers::FlatBufferBuilder &_fbb, const Uint8VectorT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
11935 (void)_rehasher;
11936 (void)_o;
11937 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const Uint8VectorT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
11938 _fbb.ForceVectorAlignment(_o->values.size(), sizeof(uint8_t), 4);
11939 auto _values = _o->values.size() ? _fbb.CreateVector(_o->values) : 0;
11940 return tflite::CreateUint8Vector(
11941 _fbb,
11942 _values);
11943}
11944
11945inline DimensionMetadataT *DimensionMetadata::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
11946 auto _o = new DimensionMetadataT();
11947 UnPackTo(_o, _resolver);
11948 return _o;
11949}
11950
11951inline void DimensionMetadata::UnPackTo(DimensionMetadataT *_o, const flatbuffers::resolver_function_t *_resolver) const {
11952 (void)_o;
11953 (void)_resolver;
11954 { auto _e = format(); _o->format = _e; }
11955 { auto _e = dense_size(); _o->dense_size = _e; }
11956 { auto _e = array_segments_type(); _o->array_segments.type = _e; }
11957 { auto _e = array_segments(); if (_e) _o->array_segments.value = tflite::SparseIndexVectorUnion::UnPack(_e, array_segments_type(), _resolver); }
11958 { auto _e = array_indices_type(); _o->array_indices.type = _e; }
11959 { auto _e = array_indices(); if (_e) _o->array_indices.value = tflite::SparseIndexVectorUnion::UnPack(_e, array_indices_type(), _resolver); }
11960}
11961
11962inline flatbuffers::Offset<DimensionMetadata> DimensionMetadata::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
11963 return CreateDimensionMetadata(_fbb, _o, _rehasher);
11964}
11965
11966inline flatbuffers::Offset<DimensionMetadata> CreateDimensionMetadata(flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
11967 (void)_rehasher;
11968 (void)_o;
11969 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DimensionMetadataT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
11970 auto _format = _o->format;
11971 auto _dense_size = _o->dense_size;
11972 auto _array_segments_type = _o->array_segments.type;
11973 auto _array_segments = _o->array_segments.Pack(_fbb);
11974 auto _array_indices_type = _o->array_indices.type;
11975 auto _array_indices = _o->array_indices.Pack(_fbb);
11976 return tflite::CreateDimensionMetadata(
11977 _fbb,
11978 _format,
11979 _dense_size,
11980 _array_segments_type,
11981 _array_segments,
11982 _array_indices_type,
11983 _array_indices);
11984}
11985
11986inline SparsityParametersT *SparsityParameters::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
11987 auto _o = new SparsityParametersT();
11988 UnPackTo(_o, _resolver);
11989 return _o;
11990}
11991
11992inline void SparsityParameters::UnPackTo(SparsityParametersT *_o, const flatbuffers::resolver_function_t *_resolver) const {
11993 (void)_o;
11994 (void)_resolver;
11995 { auto _e = traversal_order(); if (_e) { _o->traversal_order.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->traversal_order[_i] = _e->Get(_i); } } }
11996 { auto _e = block_map(); if (_e) { _o->block_map.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->block_map[_i] = _e->Get(_i); } } }
11997 { auto _e = dim_metadata(); if (_e) { _o->dim_metadata.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->dim_metadata[_i] = std::unique_ptr<tflite::DimensionMetadataT>(_e->Get(_i)->UnPack(_resolver)); } } }
11998}
11999
12000inline flatbuffers::Offset<SparsityParameters> SparsityParameters::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SparsityParametersT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12001 return CreateSparsityParameters(_fbb, _o, _rehasher);
12002}
12003
12004inline flatbuffers::Offset<SparsityParameters> CreateSparsityParameters(flatbuffers::FlatBufferBuilder &_fbb, const SparsityParametersT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
12005 (void)_rehasher;
12006 (void)_o;
12007 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SparsityParametersT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
12008 auto _traversal_order = _o->traversal_order.size() ? _fbb.CreateVector(_o->traversal_order) : 0;
12009 auto _block_map = _o->block_map.size() ? _fbb.CreateVector(_o->block_map) : 0;
12010 auto _dim_metadata = _o->dim_metadata.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::DimensionMetadata>> (_o->dim_metadata.size(), [](size_t i, _VectorArgs *__va) { return CreateDimensionMetadata(*__va->__fbb, __va->__o->dim_metadata[i].get(), __va->__rehasher); }, &_va ) : 0;
12011 return tflite::CreateSparsityParameters(
12012 _fbb,
12013 _traversal_order,
12014 _block_map,
12015 _dim_metadata);
12016}
12017
12018inline TensorT *Tensor::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
12019 auto _o = new TensorT();
12020 UnPackTo(_o, _resolver);
12021 return _o;
12022}
12023
12024inline void Tensor::UnPackTo(TensorT *_o, const flatbuffers::resolver_function_t *_resolver) const {
12025 (void)_o;
12026 (void)_resolver;
12027 { auto _e = shape(); if (_e) { _o->shape.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->shape[_i] = _e->Get(_i); } } }
12028 { auto _e = type(); _o->type = _e; }
12029 { auto _e = buffer(); _o->buffer = _e; }
12030 { auto _e = name(); if (_e) _o->name = _e->str(); }
12031 { auto _e = quantization(); if (_e) _o->quantization = std::unique_ptr<tflite::QuantizationParametersT>(_e->UnPack(_resolver)); }
12032 { auto _e = is_variable(); _o->is_variable = _e; }
12033 { auto _e = sparsity(); if (_e) _o->sparsity = std::unique_ptr<tflite::SparsityParametersT>(_e->UnPack(_resolver)); }
12034 { auto _e = shape_signature(); if (_e) { _o->shape_signature.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->shape_signature[_i] = _e->Get(_i); } } }
12035}
12036
12037inline flatbuffers::Offset<Tensor> Tensor::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12038 return CreateTensor(_fbb, _o, _rehasher);
12039}
12040
12041inline flatbuffers::Offset<Tensor> CreateTensor(flatbuffers::FlatBufferBuilder &_fbb, const TensorT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
12042 (void)_rehasher;
12043 (void)_o;
12044 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TensorT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
12045 auto _shape = _o->shape.size() ? _fbb.CreateVector(_o->shape) : 0;
12046 auto _type = _o->type;
12047 auto _buffer = _o->buffer;
12048 auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name);
12049 auto _quantization = _o->quantization ? CreateQuantizationParameters(_fbb, _o->quantization.get(), _rehasher) : 0;
12050 auto _is_variable = _o->is_variable;
12051 auto _sparsity = _o->sparsity ? CreateSparsityParameters(_fbb, _o->sparsity.get(), _rehasher) : 0;
12052 auto _shape_signature = _o->shape_signature.size() ? _fbb.CreateVector(_o->shape_signature) : 0;
12053 return tflite::CreateTensor(
12054 _fbb,
12055 _shape,
12056 _type,
12057 _buffer,
12058 _name,
12059 _quantization,
12060 _is_variable,
12061 _sparsity,
12062 _shape_signature);
12063}
12064
12065inline Conv2DOptionsT *Conv2DOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
12066 auto _o = new Conv2DOptionsT();
12067 UnPackTo(_o, _resolver);
12068 return _o;
12069}
12070
12071inline void Conv2DOptions::UnPackTo(Conv2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
12072 (void)_o;
12073 (void)_resolver;
12074 { auto _e = padding(); _o->padding = _e; }
12075 { auto _e = stride_w(); _o->stride_w = _e; }
12076 { auto _e = stride_h(); _o->stride_h = _e; }
12077 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
12078 { auto _e = dilation_w_factor(); _o->dilation_w_factor = _e; }
12079 { auto _e = dilation_h_factor(); _o->dilation_h_factor = _e; }
12080}
12081
12082inline flatbuffers::Offset<Conv2DOptions> Conv2DOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12083 return CreateConv2DOptions(_fbb, _o, _rehasher);
12084}
12085
12086inline flatbuffers::Offset<Conv2DOptions> CreateConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
12087 (void)_rehasher;
12088 (void)_o;
12089 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const Conv2DOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
12090 auto _padding = _o->padding;
12091 auto _stride_w = _o->stride_w;
12092 auto _stride_h = _o->stride_h;
12093 auto _fused_activation_function = _o->fused_activation_function;
12094 auto _dilation_w_factor = _o->dilation_w_factor;
12095 auto _dilation_h_factor = _o->dilation_h_factor;
12096 return tflite::CreateConv2DOptions(
12097 _fbb,
12098 _padding,
12099 _stride_w,
12100 _stride_h,
12101 _fused_activation_function,
12102 _dilation_w_factor,
12103 _dilation_h_factor);
12104}
12105
12106inline Conv3DOptionsT *Conv3DOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
12107 auto _o = new Conv3DOptionsT();
12108 UnPackTo(_o, _resolver);
12109 return _o;
12110}
12111
12112inline void Conv3DOptions::UnPackTo(Conv3DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
12113 (void)_o;
12114 (void)_resolver;
12115 { auto _e = padding(); _o->padding = _e; }
12116 { auto _e = stride_d(); _o->stride_d = _e; }
12117 { auto _e = stride_w(); _o->stride_w = _e; }
12118 { auto _e = stride_h(); _o->stride_h = _e; }
12119 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
12120 { auto _e = dilation_d_factor(); _o->dilation_d_factor = _e; }
12121 { auto _e = dilation_w_factor(); _o->dilation_w_factor = _e; }
12122 { auto _e = dilation_h_factor(); _o->dilation_h_factor = _e; }
12123}
12124
12125inline flatbuffers::Offset<Conv3DOptions> Conv3DOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv3DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12126 return CreateConv3DOptions(_fbb, _o, _rehasher);
12127}
12128
12129inline flatbuffers::Offset<Conv3DOptions> CreateConv3DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Conv3DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
12130 (void)_rehasher;
12131 (void)_o;
12132 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const Conv3DOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
12133 auto _padding = _o->padding;
12134 auto _stride_d = _o->stride_d;
12135 auto _stride_w = _o->stride_w;
12136 auto _stride_h = _o->stride_h;
12137 auto _fused_activation_function = _o->fused_activation_function;
12138 auto _dilation_d_factor = _o->dilation_d_factor;
12139 auto _dilation_w_factor = _o->dilation_w_factor;
12140 auto _dilation_h_factor = _o->dilation_h_factor;
12141 return tflite::CreateConv3DOptions(
12142 _fbb,
12143 _padding,
12144 _stride_d,
12145 _stride_w,
12146 _stride_h,
12147 _fused_activation_function,
12148 _dilation_d_factor,
12149 _dilation_w_factor,
12150 _dilation_h_factor);
12151}
12152
12153inline Pool2DOptionsT *Pool2DOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
12154 auto _o = new Pool2DOptionsT();
12155 UnPackTo(_o, _resolver);
12156 return _o;
12157}
12158
12159inline void Pool2DOptions::UnPackTo(Pool2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
12160 (void)_o;
12161 (void)_resolver;
12162 { auto _e = padding(); _o->padding = _e; }
12163 { auto _e = stride_w(); _o->stride_w = _e; }
12164 { auto _e = stride_h(); _o->stride_h = _e; }
12165 { auto _e = filter_width(); _o->filter_width = _e; }
12166 { auto _e = filter_height(); _o->filter_height = _e; }
12167 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
12168}
12169
12170inline flatbuffers::Offset<Pool2DOptions> Pool2DOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12171 return CreatePool2DOptions(_fbb, _o, _rehasher);
12172}
12173
12174inline flatbuffers::Offset<Pool2DOptions> CreatePool2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
12175 (void)_rehasher;
12176 (void)_o;
12177 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const Pool2DOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
12178 auto _padding = _o->padding;
12179 auto _stride_w = _o->stride_w;
12180 auto _stride_h = _o->stride_h;
12181 auto _filter_width = _o->filter_width;
12182 auto _filter_height = _o->filter_height;
12183 auto _fused_activation_function = _o->fused_activation_function;
12184 return tflite::CreatePool2DOptions(
12185 _fbb,
12186 _padding,
12187 _stride_w,
12188 _stride_h,
12189 _filter_width,
12190 _filter_height,
12191 _fused_activation_function);
12192}
12193
12194inline DepthwiseConv2DOptionsT *DepthwiseConv2DOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
12195 auto _o = new DepthwiseConv2DOptionsT();
12196 UnPackTo(_o, _resolver);
12197 return _o;
12198}
12199
12200inline void DepthwiseConv2DOptions::UnPackTo(DepthwiseConv2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
12201 (void)_o;
12202 (void)_resolver;
12203 { auto _e = padding(); _o->padding = _e; }
12204 { auto _e = stride_w(); _o->stride_w = _e; }
12205 { auto _e = stride_h(); _o->stride_h = _e; }
12206 { auto _e = depth_multiplier(); _o->depth_multiplier = _e; }
12207 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
12208 { auto _e = dilation_w_factor(); _o->dilation_w_factor = _e; }
12209 { auto _e = dilation_h_factor(); _o->dilation_h_factor = _e; }
12210}
12211
12212inline flatbuffers::Offset<DepthwiseConv2DOptions> DepthwiseConv2DOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12213 return CreateDepthwiseConv2DOptions(_fbb, _o, _rehasher);
12214}
12215
12216inline flatbuffers::Offset<DepthwiseConv2DOptions> CreateDepthwiseConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
12217 (void)_rehasher;
12218 (void)_o;
12219 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DepthwiseConv2DOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
12220 auto _padding = _o->padding;
12221 auto _stride_w = _o->stride_w;
12222 auto _stride_h = _o->stride_h;
12223 auto _depth_multiplier = _o->depth_multiplier;
12224 auto _fused_activation_function = _o->fused_activation_function;
12225 auto _dilation_w_factor = _o->dilation_w_factor;
12226 auto _dilation_h_factor = _o->dilation_h_factor;
12227 return tflite::CreateDepthwiseConv2DOptions(
12228 _fbb,
12229 _padding,
12230 _stride_w,
12231 _stride_h,
12232 _depth_multiplier,
12233 _fused_activation_function,
12234 _dilation_w_factor,
12235 _dilation_h_factor);
12236}
12237
12238inline ConcatEmbeddingsOptionsT *ConcatEmbeddingsOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
12239 auto _o = new ConcatEmbeddingsOptionsT();
12240 UnPackTo(_o, _resolver);
12241 return _o;
12242}
12243
12244inline void ConcatEmbeddingsOptions::UnPackTo(ConcatEmbeddingsOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
12245 (void)_o;
12246 (void)_resolver;
12247 { auto _e = num_channels(); _o->num_channels = _e; }
12248 { auto _e = num_columns_per_channel(); if (_e) { _o->num_columns_per_channel.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->num_columns_per_channel[_i] = _e->Get(_i); } } }
12249 { auto _e = embedding_dim_per_channel(); if (_e) { _o->embedding_dim_per_channel.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->embedding_dim_per_channel[_i] = _e->Get(_i); } } }
12250}
12251
12252inline flatbuffers::Offset<ConcatEmbeddingsOptions> ConcatEmbeddingsOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12253 return CreateConcatEmbeddingsOptions(_fbb, _o, _rehasher);
12254}
12255
12256inline flatbuffers::Offset<ConcatEmbeddingsOptions> CreateConcatEmbeddingsOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
12257 (void)_rehasher;
12258 (void)_o;
12259 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ConcatEmbeddingsOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
12260 auto _num_channels = _o->num_channels;
12261 auto _num_columns_per_channel = _o->num_columns_per_channel.size() ? _fbb.CreateVector(_o->num_columns_per_channel) : 0;
12262 auto _embedding_dim_per_channel = _o->embedding_dim_per_channel.size() ? _fbb.CreateVector(_o->embedding_dim_per_channel) : 0;
12263 return tflite::CreateConcatEmbeddingsOptions(
12264 _fbb,
12265 _num_channels,
12266 _num_columns_per_channel,
12267 _embedding_dim_per_channel);
12268}
12269
12270inline LSHProjectionOptionsT *LSHProjectionOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
12271 auto _o = new LSHProjectionOptionsT();
12272 UnPackTo(_o, _resolver);
12273 return _o;
12274}
12275
12276inline void LSHProjectionOptions::UnPackTo(LSHProjectionOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
12277 (void)_o;
12278 (void)_resolver;
12279 { auto _e = type(); _o->type = _e; }
12280}
12281
12282inline flatbuffers::Offset<LSHProjectionOptions> LSHProjectionOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12283 return CreateLSHProjectionOptions(_fbb, _o, _rehasher);
12284}
12285
12286inline flatbuffers::Offset<LSHProjectionOptions> CreateLSHProjectionOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
12287 (void)_rehasher;
12288 (void)_o;
12289 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LSHProjectionOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
12290 auto _type = _o->type;
12291 return tflite::CreateLSHProjectionOptions(
12292 _fbb,
12293 _type);
12294}
12295
12296inline SVDFOptionsT *SVDFOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
12297 auto _o = new SVDFOptionsT();
12298 UnPackTo(_o, _resolver);
12299 return _o;
12300}
12301
12302inline void SVDFOptions::UnPackTo(SVDFOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
12303 (void)_o;
12304 (void)_resolver;
12305 { auto _e = rank(); _o->rank = _e; }
12306 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
12307 { auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
12308}
12309
12310inline flatbuffers::Offset<SVDFOptions> SVDFOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12311 return CreateSVDFOptions(_fbb, _o, _rehasher);
12312}
12313
12314inline flatbuffers::Offset<SVDFOptions> CreateSVDFOptions(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
12315 (void)_rehasher;
12316 (void)_o;
12317 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SVDFOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
12318 auto _rank = _o->rank;
12319 auto _fused_activation_function = _o->fused_activation_function;
12320 auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
12321 return tflite::CreateSVDFOptions(
12322 _fbb,
12323 _rank,
12324 _fused_activation_function,
12325 _asymmetric_quantize_inputs);
12326}
12327
12328inline RNNOptionsT *RNNOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
12329 auto _o = new RNNOptionsT();
12330 UnPackTo(_o, _resolver);
12331 return _o;
12332}
12333
12334inline void RNNOptions::UnPackTo(RNNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
12335 (void)_o;
12336 (void)_resolver;
12337 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
12338 { auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
12339}
12340
12341inline flatbuffers::Offset<RNNOptions> RNNOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12342 return CreateRNNOptions(_fbb, _o, _rehasher);
12343}
12344
12345inline flatbuffers::Offset<RNNOptions> CreateRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
12346 (void)_rehasher;
12347 (void)_o;
12348 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const RNNOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
12349 auto _fused_activation_function = _o->fused_activation_function;
12350 auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
12351 return tflite::CreateRNNOptions(
12352 _fbb,
12353 _fused_activation_function,
12354 _asymmetric_quantize_inputs);
12355}
12356
12357inline SequenceRNNOptionsT *SequenceRNNOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
12358 auto _o = new SequenceRNNOptionsT();
12359 UnPackTo(_o, _resolver);
12360 return _o;
12361}
12362
12363inline void SequenceRNNOptions::UnPackTo(SequenceRNNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
12364 (void)_o;
12365 (void)_resolver;
12366 { auto _e = time_major(); _o->time_major = _e; }
12367 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
12368 { auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
12369}
12370
12371inline flatbuffers::Offset<SequenceRNNOptions> SequenceRNNOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12372 return CreateSequenceRNNOptions(_fbb, _o, _rehasher);
12373}
12374
12375inline flatbuffers::Offset<SequenceRNNOptions> CreateSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
12376 (void)_rehasher;
12377 (void)_o;
12378 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SequenceRNNOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
12379 auto _time_major = _o->time_major;
12380 auto _fused_activation_function = _o->fused_activation_function;
12381 auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
12382 return tflite::CreateSequenceRNNOptions(
12383 _fbb,
12384 _time_major,
12385 _fused_activation_function,
12386 _asymmetric_quantize_inputs);
12387}
12388
12389inline BidirectionalSequenceRNNOptionsT *BidirectionalSequenceRNNOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
12390 auto _o = new BidirectionalSequenceRNNOptionsT();
12391 UnPackTo(_o, _resolver);
12392 return _o;
12393}
12394
12395inline void BidirectionalSequenceRNNOptions::UnPackTo(BidirectionalSequenceRNNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
12396 (void)_o;
12397 (void)_resolver;
12398 { auto _e = time_major(); _o->time_major = _e; }
12399 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
12400 { auto _e = merge_outputs(); _o->merge_outputs = _e; }
12401 { auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
12402}
12403
12404inline flatbuffers::Offset<BidirectionalSequenceRNNOptions> BidirectionalSequenceRNNOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12405 return CreateBidirectionalSequenceRNNOptions(_fbb, _o, _rehasher);
12406}
12407
12408inline flatbuffers::Offset<BidirectionalSequenceRNNOptions> CreateBidirectionalSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
12409 (void)_rehasher;
12410 (void)_o;
12411 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BidirectionalSequenceRNNOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
12412 auto _time_major = _o->time_major;
12413 auto _fused_activation_function = _o->fused_activation_function;
12414 auto _merge_outputs = _o->merge_outputs;
12415 auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
12416 return tflite::CreateBidirectionalSequenceRNNOptions(
12417 _fbb,
12418 _time_major,
12419 _fused_activation_function,
12420 _merge_outputs,
12421 _asymmetric_quantize_inputs);
12422}
12423
12424inline FullyConnectedOptionsT *FullyConnectedOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
12425 auto _o = new FullyConnectedOptionsT();
12426 UnPackTo(_o, _resolver);
12427 return _o;
12428}
12429
12430inline void FullyConnectedOptions::UnPackTo(FullyConnectedOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
12431 (void)_o;
12432 (void)_resolver;
12433 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
12434 { auto _e = weights_format(); _o->weights_format = _e; }
12435 { auto _e = keep_num_dims(); _o->keep_num_dims = _e; }
12436 { auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
12437}
12438
12439inline flatbuffers::Offset<FullyConnectedOptions> FullyConnectedOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12440 return CreateFullyConnectedOptions(_fbb, _o, _rehasher);
12441}
12442
12443inline flatbuffers::Offset<FullyConnectedOptions> CreateFullyConnectedOptions(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
12444 (void)_rehasher;
12445 (void)_o;
12446 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FullyConnectedOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
12447 auto _fused_activation_function = _o->fused_activation_function;
12448 auto _weights_format = _o->weights_format;
12449 auto _keep_num_dims = _o->keep_num_dims;
12450 auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
12451 return tflite::CreateFullyConnectedOptions(
12452 _fbb,
12453 _fused_activation_function,
12454 _weights_format,
12455 _keep_num_dims,
12456 _asymmetric_quantize_inputs);
12457}
12458
12459inline SoftmaxOptionsT *SoftmaxOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
12460 auto _o = new SoftmaxOptionsT();
12461 UnPackTo(_o, _resolver);
12462 return _o;
12463}
12464
12465inline void SoftmaxOptions::UnPackTo(SoftmaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
12466 (void)_o;
12467 (void)_resolver;
12468 { auto _e = beta(); _o->beta = _e; }
12469}
12470
12471inline flatbuffers::Offset<SoftmaxOptions> SoftmaxOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12472 return CreateSoftmaxOptions(_fbb, _o, _rehasher);
12473}
12474
12475inline flatbuffers::Offset<SoftmaxOptions> CreateSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
12476 (void)_rehasher;
12477 (void)_o;
12478 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SoftmaxOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
12479 auto _beta = _o->beta;
12480 return tflite::CreateSoftmaxOptions(
12481 _fbb,
12482 _beta);
12483}
12484
12485inline ConcatenationOptionsT *ConcatenationOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
12486 auto _o = new ConcatenationOptionsT();
12487 UnPackTo(_o, _resolver);
12488 return _o;
12489}
12490
12491inline void ConcatenationOptions::UnPackTo(ConcatenationOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
12492 (void)_o;
12493 (void)_resolver;
12494 { auto _e = axis(); _o->axis = _e; }
12495 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
12496}
12497
12498inline flatbuffers::Offset<ConcatenationOptions> ConcatenationOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12499 return CreateConcatenationOptions(_fbb, _o, _rehasher);
12500}
12501
12502inline flatbuffers::Offset<ConcatenationOptions> CreateConcatenationOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
12503 (void)_rehasher;
12504 (void)_o;
12505 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ConcatenationOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
12506 auto _axis = _o->axis;
12507 auto _fused_activation_function = _o->fused_activation_function;
12508 return tflite::CreateConcatenationOptions(
12509 _fbb,
12510 _axis,
12511 _fused_activation_function);
12512}
12513
12514inline AddOptionsT *AddOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
12515 auto _o = new AddOptionsT();
12516 UnPackTo(_o, _resolver);
12517 return _o;
12518}
12519
12520inline void AddOptions::UnPackTo(AddOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
12521 (void)_o;
12522 (void)_resolver;
12523 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
12524 { auto _e = pot_scale_int16(); _o->pot_scale_int16 = _e; }
12525}
12526
12527inline flatbuffers::Offset<AddOptions> AddOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12528 return CreateAddOptions(_fbb, _o, _rehasher);
12529}
12530
12531inline flatbuffers::Offset<AddOptions> CreateAddOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
12532 (void)_rehasher;
12533 (void)_o;
12534 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const AddOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
12535 auto _fused_activation_function = _o->fused_activation_function;
12536 auto _pot_scale_int16 = _o->pot_scale_int16;
12537 return tflite::CreateAddOptions(
12538 _fbb,
12539 _fused_activation_function,
12540 _pot_scale_int16);
12541}
12542
12543inline MulOptionsT *MulOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
12544 auto _o = new MulOptionsT();
12545 UnPackTo(_o, _resolver);
12546 return _o;
12547}
12548
12549inline void MulOptions::UnPackTo(MulOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
12550 (void)_o;
12551 (void)_resolver;
12552 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
12553}
12554
12555inline flatbuffers::Offset<MulOptions> MulOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12556 return CreateMulOptions(_fbb, _o, _rehasher);
12557}
12558
12559inline flatbuffers::Offset<MulOptions> CreateMulOptions(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
12560 (void)_rehasher;
12561 (void)_o;
12562 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MulOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
12563 auto _fused_activation_function = _o->fused_activation_function;
12564 return tflite::CreateMulOptions(
12565 _fbb,
12566 _fused_activation_function);
12567}
12568
12569inline L2NormOptionsT *L2NormOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
12570 auto _o = new L2NormOptionsT();
12571 UnPackTo(_o, _resolver);
12572 return _o;
12573}
12574
12575inline void L2NormOptions::UnPackTo(L2NormOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
12576 (void)_o;
12577 (void)_resolver;
12578 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
12579}
12580
12581inline flatbuffers::Offset<L2NormOptions> L2NormOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12582 return CreateL2NormOptions(_fbb, _o, _rehasher);
12583}
12584
12585inline flatbuffers::Offset<L2NormOptions> CreateL2NormOptions(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
12586 (void)_rehasher;
12587 (void)_o;
12588 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const L2NormOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
12589 auto _fused_activation_function = _o->fused_activation_function;
12590 return tflite::CreateL2NormOptions(
12591 _fbb,
12592 _fused_activation_function);
12593}
12594
12595inline LocalResponseNormalizationOptionsT *LocalResponseNormalizationOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
12596 auto _o = new LocalResponseNormalizationOptionsT();
12597 UnPackTo(_o, _resolver);
12598 return _o;
12599}
12600
12601inline void LocalResponseNormalizationOptions::UnPackTo(LocalResponseNormalizationOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
12602 (void)_o;
12603 (void)_resolver;
12604 { auto _e = radius(); _o->radius = _e; }
12605 { auto _e = bias(); _o->bias = _e; }
12606 { auto _e = alpha(); _o->alpha = _e; }
12607 { auto _e = beta(); _o->beta = _e; }
12608}
12609
12610inline flatbuffers::Offset<LocalResponseNormalizationOptions> LocalResponseNormalizationOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12611 return CreateLocalResponseNormalizationOptions(_fbb, _o, _rehasher);
12612}
12613
12614inline flatbuffers::Offset<LocalResponseNormalizationOptions> CreateLocalResponseNormalizationOptions(flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
12615 (void)_rehasher;
12616 (void)_o;
12617 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LocalResponseNormalizationOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
12618 auto _radius = _o->radius;
12619 auto _bias = _o->bias;
12620 auto _alpha = _o->alpha;
12621 auto _beta = _o->beta;
12622 return tflite::CreateLocalResponseNormalizationOptions(
12623 _fbb,
12624 _radius,
12625 _bias,
12626 _alpha,
12627 _beta);
12628}
12629
12630inline LSTMOptionsT *LSTMOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
12631 auto _o = new LSTMOptionsT();
12632 UnPackTo(_o, _resolver);
12633 return _o;
12634}
12635
12636inline void LSTMOptions::UnPackTo(LSTMOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
12637 (void)_o;
12638 (void)_resolver;
12639 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
12640 { auto _e = cell_clip(); _o->cell_clip = _e; }
12641 { auto _e = proj_clip(); _o->proj_clip = _e; }
12642 { auto _e = kernel_type(); _o->kernel_type = _e; }
12643 { auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
12644}
12645
12646inline flatbuffers::Offset<LSTMOptions> LSTMOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12647 return CreateLSTMOptions(_fbb, _o, _rehasher);
12648}
12649
12650inline flatbuffers::Offset<LSTMOptions> CreateLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
12651 (void)_rehasher;
12652 (void)_o;
12653 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LSTMOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
12654 auto _fused_activation_function = _o->fused_activation_function;
12655 auto _cell_clip = _o->cell_clip;
12656 auto _proj_clip = _o->proj_clip;
12657 auto _kernel_type = _o->kernel_type;
12658 auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
12659 return tflite::CreateLSTMOptions(
12660 _fbb,
12661 _fused_activation_function,
12662 _cell_clip,
12663 _proj_clip,
12664 _kernel_type,
12665 _asymmetric_quantize_inputs);
12666}
12667
12668inline UnidirectionalSequenceLSTMOptionsT *UnidirectionalSequenceLSTMOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
12669 auto _o = new UnidirectionalSequenceLSTMOptionsT();
12670 UnPackTo(_o, _resolver);
12671 return _o;
12672}
12673
12674inline void UnidirectionalSequenceLSTMOptions::UnPackTo(UnidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
12675 (void)_o;
12676 (void)_resolver;
12677 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
12678 { auto _e = cell_clip(); _o->cell_clip = _e; }
12679 { auto _e = proj_clip(); _o->proj_clip = _e; }
12680 { auto _e = time_major(); _o->time_major = _e; }
12681 { auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
12682}
12683
12684inline flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> UnidirectionalSequenceLSTMOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12685 return CreateUnidirectionalSequenceLSTMOptions(_fbb, _o, _rehasher);
12686}
12687
12688inline flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> CreateUnidirectionalSequenceLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
12689 (void)_rehasher;
12690 (void)_o;
12691 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const UnidirectionalSequenceLSTMOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
12692 auto _fused_activation_function = _o->fused_activation_function;
12693 auto _cell_clip = _o->cell_clip;
12694 auto _proj_clip = _o->proj_clip;
12695 auto _time_major = _o->time_major;
12696 auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
12697 return tflite::CreateUnidirectionalSequenceLSTMOptions(
12698 _fbb,
12699 _fused_activation_function,
12700 _cell_clip,
12701 _proj_clip,
12702 _time_major,
12703 _asymmetric_quantize_inputs);
12704}
12705
12706inline BidirectionalSequenceLSTMOptionsT *BidirectionalSequenceLSTMOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
12707 auto _o = new BidirectionalSequenceLSTMOptionsT();
12708 UnPackTo(_o, _resolver);
12709 return _o;
12710}
12711
12712inline void BidirectionalSequenceLSTMOptions::UnPackTo(BidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
12713 (void)_o;
12714 (void)_resolver;
12715 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
12716 { auto _e = cell_clip(); _o->cell_clip = _e; }
12717 { auto _e = proj_clip(); _o->proj_clip = _e; }
12718 { auto _e = merge_outputs(); _o->merge_outputs = _e; }
12719 { auto _e = time_major(); _o->time_major = _e; }
12720 { auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
12721}
12722
12723inline flatbuffers::Offset<BidirectionalSequenceLSTMOptions> BidirectionalSequenceLSTMOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12724 return CreateBidirectionalSequenceLSTMOptions(_fbb, _o, _rehasher);
12725}
12726
12727inline flatbuffers::Offset<BidirectionalSequenceLSTMOptions> CreateBidirectionalSequenceLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
12728 (void)_rehasher;
12729 (void)_o;
12730 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BidirectionalSequenceLSTMOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
12731 auto _fused_activation_function = _o->fused_activation_function;
12732 auto _cell_clip = _o->cell_clip;
12733 auto _proj_clip = _o->proj_clip;
12734 auto _merge_outputs = _o->merge_outputs;
12735 auto _time_major = _o->time_major;
12736 auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
12737 return tflite::CreateBidirectionalSequenceLSTMOptions(
12738 _fbb,
12739 _fused_activation_function,
12740 _cell_clip,
12741 _proj_clip,
12742 _merge_outputs,
12743 _time_major,
12744 _asymmetric_quantize_inputs);
12745}
12746
12747inline ResizeBilinearOptionsT *ResizeBilinearOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
12748 auto _o = new ResizeBilinearOptionsT();
12749 UnPackTo(_o, _resolver);
12750 return _o;
12751}
12752
12753inline void ResizeBilinearOptions::UnPackTo(ResizeBilinearOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
12754 (void)_o;
12755 (void)_resolver;
12756 { auto _e = align_corners(); _o->align_corners = _e; }
12757 { auto _e = half_pixel_centers(); _o->half_pixel_centers = _e; }
12758}
12759
12760inline flatbuffers::Offset<ResizeBilinearOptions> ResizeBilinearOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12761 return CreateResizeBilinearOptions(_fbb, _o, _rehasher);
12762}
12763
12764inline flatbuffers::Offset<ResizeBilinearOptions> CreateResizeBilinearOptions(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
12765 (void)_rehasher;
12766 (void)_o;
12767 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ResizeBilinearOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
12768 auto _align_corners = _o->align_corners;
12769 auto _half_pixel_centers = _o->half_pixel_centers;
12770 return tflite::CreateResizeBilinearOptions(
12771 _fbb,
12772 _align_corners,
12773 _half_pixel_centers);
12774}
12775
12776inline ResizeNearestNeighborOptionsT *ResizeNearestNeighborOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
12777 auto _o = new ResizeNearestNeighborOptionsT();
12778 UnPackTo(_o, _resolver);
12779 return _o;
12780}
12781
12782inline void ResizeNearestNeighborOptions::UnPackTo(ResizeNearestNeighborOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
12783 (void)_o;
12784 (void)_resolver;
12785 { auto _e = align_corners(); _o->align_corners = _e; }
12786 { auto _e = half_pixel_centers(); _o->half_pixel_centers = _e; }
12787}
12788
12789inline flatbuffers::Offset<ResizeNearestNeighborOptions> ResizeNearestNeighborOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12790 return CreateResizeNearestNeighborOptions(_fbb, _o, _rehasher);
12791}
12792
12793inline flatbuffers::Offset<ResizeNearestNeighborOptions> CreateResizeNearestNeighborOptions(flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
12794 (void)_rehasher;
12795 (void)_o;
12796 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ResizeNearestNeighborOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
12797 auto _align_corners = _o->align_corners;
12798 auto _half_pixel_centers = _o->half_pixel_centers;
12799 return tflite::CreateResizeNearestNeighborOptions(
12800 _fbb,
12801 _align_corners,
12802 _half_pixel_centers);
12803}
12804
12805inline CallOptionsT *CallOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
12806 auto _o = new CallOptionsT();
12807 UnPackTo(_o, _resolver);
12808 return _o;
12809}
12810
12811inline void CallOptions::UnPackTo(CallOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
12812 (void)_o;
12813 (void)_resolver;
12814 { auto _e = subgraph(); _o->subgraph = _e; }
12815}
12816
12817inline flatbuffers::Offset<CallOptions> CallOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12818 return CreateCallOptions(_fbb, _o, _rehasher);
12819}
12820
12821inline flatbuffers::Offset<CallOptions> CreateCallOptions(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
12822 (void)_rehasher;
12823 (void)_o;
12824 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const CallOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
12825 auto _subgraph = _o->subgraph;
12826 return tflite::CreateCallOptions(
12827 _fbb,
12828 _subgraph);
12829}
12830
12831inline PadOptionsT *PadOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
12832 auto _o = new PadOptionsT();
12833 UnPackTo(_o, _resolver);
12834 return _o;
12835}
12836
12837inline void PadOptions::UnPackTo(PadOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
12838 (void)_o;
12839 (void)_resolver;
12840}
12841
12842inline flatbuffers::Offset<PadOptions> PadOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12843 return CreatePadOptions(_fbb, _o, _rehasher);
12844}
12845
12846inline flatbuffers::Offset<PadOptions> CreatePadOptions(flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
12847 (void)_rehasher;
12848 (void)_o;
12849 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PadOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
12850 return tflite::CreatePadOptions(
12851 _fbb);
12852}
12853
12854inline PadV2OptionsT *PadV2Options::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
12855 auto _o = new PadV2OptionsT();
12856 UnPackTo(_o, _resolver);
12857 return _o;
12858}
12859
12860inline void PadV2Options::UnPackTo(PadV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
12861 (void)_o;
12862 (void)_resolver;
12863}
12864
12865inline flatbuffers::Offset<PadV2Options> PadV2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12866 return CreatePadV2Options(_fbb, _o, _rehasher);
12867}
12868
12869inline flatbuffers::Offset<PadV2Options> CreatePadV2Options(flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
12870 (void)_rehasher;
12871 (void)_o;
12872 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PadV2OptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
12873 return tflite::CreatePadV2Options(
12874 _fbb);
12875}
12876
12877inline ReshapeOptionsT *ReshapeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
12878 auto _o = new ReshapeOptionsT();
12879 UnPackTo(_o, _resolver);
12880 return _o;
12881}
12882
12883inline void ReshapeOptions::UnPackTo(ReshapeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
12884 (void)_o;
12885 (void)_resolver;
12886 { auto _e = new_shape(); if (_e) { _o->new_shape.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->new_shape[_i] = _e->Get(_i); } } }
12887}
12888
12889inline flatbuffers::Offset<ReshapeOptions> ReshapeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12890 return CreateReshapeOptions(_fbb, _o, _rehasher);
12891}
12892
12893inline flatbuffers::Offset<ReshapeOptions> CreateReshapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
12894 (void)_rehasher;
12895 (void)_o;
12896 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ReshapeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
12897 auto _new_shape = _o->new_shape.size() ? _fbb.CreateVector(_o->new_shape) : 0;
12898 return tflite::CreateReshapeOptions(
12899 _fbb,
12900 _new_shape);
12901}
12902
12903inline SpaceToBatchNDOptionsT *SpaceToBatchNDOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
12904 auto _o = new SpaceToBatchNDOptionsT();
12905 UnPackTo(_o, _resolver);
12906 return _o;
12907}
12908
12909inline void SpaceToBatchNDOptions::UnPackTo(SpaceToBatchNDOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
12910 (void)_o;
12911 (void)_resolver;
12912}
12913
12914inline flatbuffers::Offset<SpaceToBatchNDOptions> SpaceToBatchNDOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12915 return CreateSpaceToBatchNDOptions(_fbb, _o, _rehasher);
12916}
12917
12918inline flatbuffers::Offset<SpaceToBatchNDOptions> CreateSpaceToBatchNDOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
12919 (void)_rehasher;
12920 (void)_o;
12921 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SpaceToBatchNDOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
12922 return tflite::CreateSpaceToBatchNDOptions(
12923 _fbb);
12924}
12925
12926inline BatchToSpaceNDOptionsT *BatchToSpaceNDOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
12927 auto _o = new BatchToSpaceNDOptionsT();
12928 UnPackTo(_o, _resolver);
12929 return _o;
12930}
12931
12932inline void BatchToSpaceNDOptions::UnPackTo(BatchToSpaceNDOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
12933 (void)_o;
12934 (void)_resolver;
12935}
12936
12937inline flatbuffers::Offset<BatchToSpaceNDOptions> BatchToSpaceNDOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12938 return CreateBatchToSpaceNDOptions(_fbb, _o, _rehasher);
12939}
12940
12941inline flatbuffers::Offset<BatchToSpaceNDOptions> CreateBatchToSpaceNDOptions(flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
12942 (void)_rehasher;
12943 (void)_o;
12944 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BatchToSpaceNDOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
12945 return tflite::CreateBatchToSpaceNDOptions(
12946 _fbb);
12947}
12948
12949inline SkipGramOptionsT *SkipGramOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
12950 auto _o = new SkipGramOptionsT();
12951 UnPackTo(_o, _resolver);
12952 return _o;
12953}
12954
12955inline void SkipGramOptions::UnPackTo(SkipGramOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
12956 (void)_o;
12957 (void)_resolver;
12958 { auto _e = ngram_size(); _o->ngram_size = _e; }
12959 { auto _e = max_skip_size(); _o->max_skip_size = _e; }
12960 { auto _e = include_all_ngrams(); _o->include_all_ngrams = _e; }
12961}
12962
12963inline flatbuffers::Offset<SkipGramOptions> SkipGramOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12964 return CreateSkipGramOptions(_fbb, _o, _rehasher);
12965}
12966
12967inline flatbuffers::Offset<SkipGramOptions> CreateSkipGramOptions(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
12968 (void)_rehasher;
12969 (void)_o;
12970 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SkipGramOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
12971 auto _ngram_size = _o->ngram_size;
12972 auto _max_skip_size = _o->max_skip_size;
12973 auto _include_all_ngrams = _o->include_all_ngrams;
12974 return tflite::CreateSkipGramOptions(
12975 _fbb,
12976 _ngram_size,
12977 _max_skip_size,
12978 _include_all_ngrams);
12979}
12980
12981inline SpaceToDepthOptionsT *SpaceToDepthOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
12982 auto _o = new SpaceToDepthOptionsT();
12983 UnPackTo(_o, _resolver);
12984 return _o;
12985}
12986
12987inline void SpaceToDepthOptions::UnPackTo(SpaceToDepthOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
12988 (void)_o;
12989 (void)_resolver;
12990 { auto _e = block_size(); _o->block_size = _e; }
12991}
12992
12993inline flatbuffers::Offset<SpaceToDepthOptions> SpaceToDepthOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12994 return CreateSpaceToDepthOptions(_fbb, _o, _rehasher);
12995}
12996
12997inline flatbuffers::Offset<SpaceToDepthOptions> CreateSpaceToDepthOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
12998 (void)_rehasher;
12999 (void)_o;
13000 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SpaceToDepthOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13001 auto _block_size = _o->block_size;
13002 return tflite::CreateSpaceToDepthOptions(
13003 _fbb,
13004 _block_size);
13005}
13006
13007inline DepthToSpaceOptionsT *DepthToSpaceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13008 auto _o = new DepthToSpaceOptionsT();
13009 UnPackTo(_o, _resolver);
13010 return _o;
13011}
13012
13013inline void DepthToSpaceOptions::UnPackTo(DepthToSpaceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13014 (void)_o;
13015 (void)_resolver;
13016 { auto _e = block_size(); _o->block_size = _e; }
13017}
13018
13019inline flatbuffers::Offset<DepthToSpaceOptions> DepthToSpaceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DepthToSpaceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13020 return CreateDepthToSpaceOptions(_fbb, _o, _rehasher);
13021}
13022
13023inline flatbuffers::Offset<DepthToSpaceOptions> CreateDepthToSpaceOptions(flatbuffers::FlatBufferBuilder &_fbb, const DepthToSpaceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13024 (void)_rehasher;
13025 (void)_o;
13026 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DepthToSpaceOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13027 auto _block_size = _o->block_size;
13028 return tflite::CreateDepthToSpaceOptions(
13029 _fbb,
13030 _block_size);
13031}
13032
13033inline SubOptionsT *SubOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13034 auto _o = new SubOptionsT();
13035 UnPackTo(_o, _resolver);
13036 return _o;
13037}
13038
13039inline void SubOptions::UnPackTo(SubOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13040 (void)_o;
13041 (void)_resolver;
13042 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
13043 { auto _e = pot_scale_int16(); _o->pot_scale_int16 = _e; }
13044}
13045
13046inline flatbuffers::Offset<SubOptions> SubOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13047 return CreateSubOptions(_fbb, _o, _rehasher);
13048}
13049
13050inline flatbuffers::Offset<SubOptions> CreateSubOptions(flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13051 (void)_rehasher;
13052 (void)_o;
13053 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SubOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13054 auto _fused_activation_function = _o->fused_activation_function;
13055 auto _pot_scale_int16 = _o->pot_scale_int16;
13056 return tflite::CreateSubOptions(
13057 _fbb,
13058 _fused_activation_function,
13059 _pot_scale_int16);
13060}
13061
13062inline DivOptionsT *DivOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13063 auto _o = new DivOptionsT();
13064 UnPackTo(_o, _resolver);
13065 return _o;
13066}
13067
13068inline void DivOptions::UnPackTo(DivOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13069 (void)_o;
13070 (void)_resolver;
13071 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
13072}
13073
13074inline flatbuffers::Offset<DivOptions> DivOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13075 return CreateDivOptions(_fbb, _o, _rehasher);
13076}
13077
13078inline flatbuffers::Offset<DivOptions> CreateDivOptions(flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13079 (void)_rehasher;
13080 (void)_o;
13081 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DivOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13082 auto _fused_activation_function = _o->fused_activation_function;
13083 return tflite::CreateDivOptions(
13084 _fbb,
13085 _fused_activation_function);
13086}
13087
13088inline TopKV2OptionsT *TopKV2Options::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13089 auto _o = new TopKV2OptionsT();
13090 UnPackTo(_o, _resolver);
13091 return _o;
13092}
13093
13094inline void TopKV2Options::UnPackTo(TopKV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13095 (void)_o;
13096 (void)_resolver;
13097}
13098
13099inline flatbuffers::Offset<TopKV2Options> TopKV2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13100 return CreateTopKV2Options(_fbb, _o, _rehasher);
13101}
13102
13103inline flatbuffers::Offset<TopKV2Options> CreateTopKV2Options(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13104 (void)_rehasher;
13105 (void)_o;
13106 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TopKV2OptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13107 return tflite::CreateTopKV2Options(
13108 _fbb);
13109}
13110
13111inline EmbeddingLookupSparseOptionsT *EmbeddingLookupSparseOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13112 auto _o = new EmbeddingLookupSparseOptionsT();
13113 UnPackTo(_o, _resolver);
13114 return _o;
13115}
13116
13117inline void EmbeddingLookupSparseOptions::UnPackTo(EmbeddingLookupSparseOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13118 (void)_o;
13119 (void)_resolver;
13120 { auto _e = combiner(); _o->combiner = _e; }
13121}
13122
13123inline flatbuffers::Offset<EmbeddingLookupSparseOptions> EmbeddingLookupSparseOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13124 return CreateEmbeddingLookupSparseOptions(_fbb, _o, _rehasher);
13125}
13126
13127inline flatbuffers::Offset<EmbeddingLookupSparseOptions> CreateEmbeddingLookupSparseOptions(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13128 (void)_rehasher;
13129 (void)_o;
13130 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const EmbeddingLookupSparseOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13131 auto _combiner = _o->combiner;
13132 return tflite::CreateEmbeddingLookupSparseOptions(
13133 _fbb,
13134 _combiner);
13135}
13136
13137inline GatherOptionsT *GatherOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13138 auto _o = new GatherOptionsT();
13139 UnPackTo(_o, _resolver);
13140 return _o;
13141}
13142
13143inline void GatherOptions::UnPackTo(GatherOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13144 (void)_o;
13145 (void)_resolver;
13146 { auto _e = axis(); _o->axis = _e; }
13147 { auto _e = batch_dims(); _o->batch_dims = _e; }
13148}
13149
13150inline flatbuffers::Offset<GatherOptions> GatherOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13151 return CreateGatherOptions(_fbb, _o, _rehasher);
13152}
13153
13154inline flatbuffers::Offset<GatherOptions> CreateGatherOptions(flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13155 (void)_rehasher;
13156 (void)_o;
13157 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const GatherOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13158 auto _axis = _o->axis;
13159 auto _batch_dims = _o->batch_dims;
13160 return tflite::CreateGatherOptions(
13161 _fbb,
13162 _axis,
13163 _batch_dims);
13164}
13165
13166inline TransposeOptionsT *TransposeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13167 auto _o = new TransposeOptionsT();
13168 UnPackTo(_o, _resolver);
13169 return _o;
13170}
13171
13172inline void TransposeOptions::UnPackTo(TransposeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13173 (void)_o;
13174 (void)_resolver;
13175}
13176
13177inline flatbuffers::Offset<TransposeOptions> TransposeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13178 return CreateTransposeOptions(_fbb, _o, _rehasher);
13179}
13180
13181inline flatbuffers::Offset<TransposeOptions> CreateTransposeOptions(flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13182 (void)_rehasher;
13183 (void)_o;
13184 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TransposeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13185 return tflite::CreateTransposeOptions(
13186 _fbb);
13187}
13188
13189inline ExpOptionsT *ExpOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13190 auto _o = new ExpOptionsT();
13191 UnPackTo(_o, _resolver);
13192 return _o;
13193}
13194
13195inline void ExpOptions::UnPackTo(ExpOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13196 (void)_o;
13197 (void)_resolver;
13198}
13199
13200inline flatbuffers::Offset<ExpOptions> ExpOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13201 return CreateExpOptions(_fbb, _o, _rehasher);
13202}
13203
13204inline flatbuffers::Offset<ExpOptions> CreateExpOptions(flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13205 (void)_rehasher;
13206 (void)_o;
13207 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ExpOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13208 return tflite::CreateExpOptions(
13209 _fbb);
13210}
13211
13212inline CosOptionsT *CosOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13213 auto _o = new CosOptionsT();
13214 UnPackTo(_o, _resolver);
13215 return _o;
13216}
13217
13218inline void CosOptions::UnPackTo(CosOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13219 (void)_o;
13220 (void)_resolver;
13221}
13222
13223inline flatbuffers::Offset<CosOptions> CosOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13224 return CreateCosOptions(_fbb, _o, _rehasher);
13225}
13226
13227inline flatbuffers::Offset<CosOptions> CreateCosOptions(flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13228 (void)_rehasher;
13229 (void)_o;
13230 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const CosOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13231 return tflite::CreateCosOptions(
13232 _fbb);
13233}
13234
13235inline ReducerOptionsT *ReducerOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13236 auto _o = new ReducerOptionsT();
13237 UnPackTo(_o, _resolver);
13238 return _o;
13239}
13240
13241inline void ReducerOptions::UnPackTo(ReducerOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13242 (void)_o;
13243 (void)_resolver;
13244 { auto _e = keep_dims(); _o->keep_dims = _e; }
13245}
13246
13247inline flatbuffers::Offset<ReducerOptions> ReducerOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13248 return CreateReducerOptions(_fbb, _o, _rehasher);
13249}
13250
13251inline flatbuffers::Offset<ReducerOptions> CreateReducerOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13252 (void)_rehasher;
13253 (void)_o;
13254 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ReducerOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13255 auto _keep_dims = _o->keep_dims;
13256 return tflite::CreateReducerOptions(
13257 _fbb,
13258 _keep_dims);
13259}
13260
13261inline SqueezeOptionsT *SqueezeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13262 auto _o = new SqueezeOptionsT();
13263 UnPackTo(_o, _resolver);
13264 return _o;
13265}
13266
13267inline void SqueezeOptions::UnPackTo(SqueezeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13268 (void)_o;
13269 (void)_resolver;
13270 { auto _e = squeeze_dims(); if (_e) { _o->squeeze_dims.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->squeeze_dims[_i] = _e->Get(_i); } } }
13271}
13272
13273inline flatbuffers::Offset<SqueezeOptions> SqueezeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13274 return CreateSqueezeOptions(_fbb, _o, _rehasher);
13275}
13276
13277inline flatbuffers::Offset<SqueezeOptions> CreateSqueezeOptions(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13278 (void)_rehasher;
13279 (void)_o;
13280 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SqueezeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13281 auto _squeeze_dims = _o->squeeze_dims.size() ? _fbb.CreateVector(_o->squeeze_dims) : 0;
13282 return tflite::CreateSqueezeOptions(
13283 _fbb,
13284 _squeeze_dims);
13285}
13286
13287inline SplitOptionsT *SplitOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13288 auto _o = new SplitOptionsT();
13289 UnPackTo(_o, _resolver);
13290 return _o;
13291}
13292
13293inline void SplitOptions::UnPackTo(SplitOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13294 (void)_o;
13295 (void)_resolver;
13296 { auto _e = num_splits(); _o->num_splits = _e; }
13297}
13298
13299inline flatbuffers::Offset<SplitOptions> SplitOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13300 return CreateSplitOptions(_fbb, _o, _rehasher);
13301}
13302
13303inline flatbuffers::Offset<SplitOptions> CreateSplitOptions(flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13304 (void)_rehasher;
13305 (void)_o;
13306 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SplitOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13307 auto _num_splits = _o->num_splits;
13308 return tflite::CreateSplitOptions(
13309 _fbb,
13310 _num_splits);
13311}
13312
13313inline SplitVOptionsT *SplitVOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13314 auto _o = new SplitVOptionsT();
13315 UnPackTo(_o, _resolver);
13316 return _o;
13317}
13318
13319inline void SplitVOptions::UnPackTo(SplitVOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13320 (void)_o;
13321 (void)_resolver;
13322 { auto _e = num_splits(); _o->num_splits = _e; }
13323}
13324
13325inline flatbuffers::Offset<SplitVOptions> SplitVOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13326 return CreateSplitVOptions(_fbb, _o, _rehasher);
13327}
13328
13329inline flatbuffers::Offset<SplitVOptions> CreateSplitVOptions(flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13330 (void)_rehasher;
13331 (void)_o;
13332 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SplitVOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13333 auto _num_splits = _o->num_splits;
13334 return tflite::CreateSplitVOptions(
13335 _fbb,
13336 _num_splits);
13337}
13338
13339inline StridedSliceOptionsT *StridedSliceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13340 auto _o = new StridedSliceOptionsT();
13341 UnPackTo(_o, _resolver);
13342 return _o;
13343}
13344
13345inline void StridedSliceOptions::UnPackTo(StridedSliceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13346 (void)_o;
13347 (void)_resolver;
13348 { auto _e = begin_mask(); _o->begin_mask = _e; }
13349 { auto _e = end_mask(); _o->end_mask = _e; }
13350 { auto _e = ellipsis_mask(); _o->ellipsis_mask = _e; }
13351 { auto _e = new_axis_mask(); _o->new_axis_mask = _e; }
13352 { auto _e = shrink_axis_mask(); _o->shrink_axis_mask = _e; }
13353}
13354
13355inline flatbuffers::Offset<StridedSliceOptions> StridedSliceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13356 return CreateStridedSliceOptions(_fbb, _o, _rehasher);
13357}
13358
13359inline flatbuffers::Offset<StridedSliceOptions> CreateStridedSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13360 (void)_rehasher;
13361 (void)_o;
13362 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const StridedSliceOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13363 auto _begin_mask = _o->begin_mask;
13364 auto _end_mask = _o->end_mask;
13365 auto _ellipsis_mask = _o->ellipsis_mask;
13366 auto _new_axis_mask = _o->new_axis_mask;
13367 auto _shrink_axis_mask = _o->shrink_axis_mask;
13368 return tflite::CreateStridedSliceOptions(
13369 _fbb,
13370 _begin_mask,
13371 _end_mask,
13372 _ellipsis_mask,
13373 _new_axis_mask,
13374 _shrink_axis_mask);
13375}
13376
13377inline LogSoftmaxOptionsT *LogSoftmaxOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13378 auto _o = new LogSoftmaxOptionsT();
13379 UnPackTo(_o, _resolver);
13380 return _o;
13381}
13382
13383inline void LogSoftmaxOptions::UnPackTo(LogSoftmaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13384 (void)_o;
13385 (void)_resolver;
13386}
13387
13388inline flatbuffers::Offset<LogSoftmaxOptions> LogSoftmaxOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13389 return CreateLogSoftmaxOptions(_fbb, _o, _rehasher);
13390}
13391
13392inline flatbuffers::Offset<LogSoftmaxOptions> CreateLogSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13393 (void)_rehasher;
13394 (void)_o;
13395 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LogSoftmaxOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13396 return tflite::CreateLogSoftmaxOptions(
13397 _fbb);
13398}
13399
13400inline CastOptionsT *CastOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13401 auto _o = new CastOptionsT();
13402 UnPackTo(_o, _resolver);
13403 return _o;
13404}
13405
13406inline void CastOptions::UnPackTo(CastOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13407 (void)_o;
13408 (void)_resolver;
13409 { auto _e = in_data_type(); _o->in_data_type = _e; }
13410 { auto _e = out_data_type(); _o->out_data_type = _e; }
13411}
13412
13413inline flatbuffers::Offset<CastOptions> CastOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13414 return CreateCastOptions(_fbb, _o, _rehasher);
13415}
13416
13417inline flatbuffers::Offset<CastOptions> CreateCastOptions(flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13418 (void)_rehasher;
13419 (void)_o;
13420 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const CastOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13421 auto _in_data_type = _o->in_data_type;
13422 auto _out_data_type = _o->out_data_type;
13423 return tflite::CreateCastOptions(
13424 _fbb,
13425 _in_data_type,
13426 _out_data_type);
13427}
13428
13429inline DequantizeOptionsT *DequantizeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13430 auto _o = new DequantizeOptionsT();
13431 UnPackTo(_o, _resolver);
13432 return _o;
13433}
13434
13435inline void DequantizeOptions::UnPackTo(DequantizeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13436 (void)_o;
13437 (void)_resolver;
13438}
13439
13440inline flatbuffers::Offset<DequantizeOptions> DequantizeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13441 return CreateDequantizeOptions(_fbb, _o, _rehasher);
13442}
13443
13444inline flatbuffers::Offset<DequantizeOptions> CreateDequantizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13445 (void)_rehasher;
13446 (void)_o;
13447 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DequantizeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13448 return tflite::CreateDequantizeOptions(
13449 _fbb);
13450}
13451
13452inline MaximumMinimumOptionsT *MaximumMinimumOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13453 auto _o = new MaximumMinimumOptionsT();
13454 UnPackTo(_o, _resolver);
13455 return _o;
13456}
13457
13458inline void MaximumMinimumOptions::UnPackTo(MaximumMinimumOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13459 (void)_o;
13460 (void)_resolver;
13461}
13462
13463inline flatbuffers::Offset<MaximumMinimumOptions> MaximumMinimumOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13464 return CreateMaximumMinimumOptions(_fbb, _o, _rehasher);
13465}
13466
13467inline flatbuffers::Offset<MaximumMinimumOptions> CreateMaximumMinimumOptions(flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13468 (void)_rehasher;
13469 (void)_o;
13470 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MaximumMinimumOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13471 return tflite::CreateMaximumMinimumOptions(
13472 _fbb);
13473}
13474
13475inline TileOptionsT *TileOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13476 auto _o = new TileOptionsT();
13477 UnPackTo(_o, _resolver);
13478 return _o;
13479}
13480
13481inline void TileOptions::UnPackTo(TileOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13482 (void)_o;
13483 (void)_resolver;
13484}
13485
13486inline flatbuffers::Offset<TileOptions> TileOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13487 return CreateTileOptions(_fbb, _o, _rehasher);
13488}
13489
13490inline flatbuffers::Offset<TileOptions> CreateTileOptions(flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13491 (void)_rehasher;
13492 (void)_o;
13493 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TileOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13494 return tflite::CreateTileOptions(
13495 _fbb);
13496}
13497
13498inline ArgMaxOptionsT *ArgMaxOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13499 auto _o = new ArgMaxOptionsT();
13500 UnPackTo(_o, _resolver);
13501 return _o;
13502}
13503
13504inline void ArgMaxOptions::UnPackTo(ArgMaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13505 (void)_o;
13506 (void)_resolver;
13507 { auto _e = output_type(); _o->output_type = _e; }
13508}
13509
13510inline flatbuffers::Offset<ArgMaxOptions> ArgMaxOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13511 return CreateArgMaxOptions(_fbb, _o, _rehasher);
13512}
13513
13514inline flatbuffers::Offset<ArgMaxOptions> CreateArgMaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13515 (void)_rehasher;
13516 (void)_o;
13517 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ArgMaxOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13518 auto _output_type = _o->output_type;
13519 return tflite::CreateArgMaxOptions(
13520 _fbb,
13521 _output_type);
13522}
13523
13524inline ArgMinOptionsT *ArgMinOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13525 auto _o = new ArgMinOptionsT();
13526 UnPackTo(_o, _resolver);
13527 return _o;
13528}
13529
13530inline void ArgMinOptions::UnPackTo(ArgMinOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13531 (void)_o;
13532 (void)_resolver;
13533 { auto _e = output_type(); _o->output_type = _e; }
13534}
13535
13536inline flatbuffers::Offset<ArgMinOptions> ArgMinOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13537 return CreateArgMinOptions(_fbb, _o, _rehasher);
13538}
13539
13540inline flatbuffers::Offset<ArgMinOptions> CreateArgMinOptions(flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13541 (void)_rehasher;
13542 (void)_o;
13543 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ArgMinOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13544 auto _output_type = _o->output_type;
13545 return tflite::CreateArgMinOptions(
13546 _fbb,
13547 _output_type);
13548}
13549
13550inline GreaterOptionsT *GreaterOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13551 auto _o = new GreaterOptionsT();
13552 UnPackTo(_o, _resolver);
13553 return _o;
13554}
13555
13556inline void GreaterOptions::UnPackTo(GreaterOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13557 (void)_o;
13558 (void)_resolver;
13559}
13560
13561inline flatbuffers::Offset<GreaterOptions> GreaterOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13562 return CreateGreaterOptions(_fbb, _o, _rehasher);
13563}
13564
13565inline flatbuffers::Offset<GreaterOptions> CreateGreaterOptions(flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13566 (void)_rehasher;
13567 (void)_o;
13568 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const GreaterOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13569 return tflite::CreateGreaterOptions(
13570 _fbb);
13571}
13572
13573inline GreaterEqualOptionsT *GreaterEqualOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13574 auto _o = new GreaterEqualOptionsT();
13575 UnPackTo(_o, _resolver);
13576 return _o;
13577}
13578
13579inline void GreaterEqualOptions::UnPackTo(GreaterEqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13580 (void)_o;
13581 (void)_resolver;
13582}
13583
13584inline flatbuffers::Offset<GreaterEqualOptions> GreaterEqualOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13585 return CreateGreaterEqualOptions(_fbb, _o, _rehasher);
13586}
13587
13588inline flatbuffers::Offset<GreaterEqualOptions> CreateGreaterEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13589 (void)_rehasher;
13590 (void)_o;
13591 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const GreaterEqualOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13592 return tflite::CreateGreaterEqualOptions(
13593 _fbb);
13594}
13595
13596inline LessOptionsT *LessOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13597 auto _o = new LessOptionsT();
13598 UnPackTo(_o, _resolver);
13599 return _o;
13600}
13601
13602inline void LessOptions::UnPackTo(LessOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13603 (void)_o;
13604 (void)_resolver;
13605}
13606
13607inline flatbuffers::Offset<LessOptions> LessOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13608 return CreateLessOptions(_fbb, _o, _rehasher);
13609}
13610
13611inline flatbuffers::Offset<LessOptions> CreateLessOptions(flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13612 (void)_rehasher;
13613 (void)_o;
13614 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LessOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13615 return tflite::CreateLessOptions(
13616 _fbb);
13617}
13618
13619inline LessEqualOptionsT *LessEqualOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13620 auto _o = new LessEqualOptionsT();
13621 UnPackTo(_o, _resolver);
13622 return _o;
13623}
13624
13625inline void LessEqualOptions::UnPackTo(LessEqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13626 (void)_o;
13627 (void)_resolver;
13628}
13629
13630inline flatbuffers::Offset<LessEqualOptions> LessEqualOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13631 return CreateLessEqualOptions(_fbb, _o, _rehasher);
13632}
13633
13634inline flatbuffers::Offset<LessEqualOptions> CreateLessEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13635 (void)_rehasher;
13636 (void)_o;
13637 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LessEqualOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13638 return tflite::CreateLessEqualOptions(
13639 _fbb);
13640}
13641
13642inline NegOptionsT *NegOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13643 auto _o = new NegOptionsT();
13644 UnPackTo(_o, _resolver);
13645 return _o;
13646}
13647
13648inline void NegOptions::UnPackTo(NegOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13649 (void)_o;
13650 (void)_resolver;
13651}
13652
13653inline flatbuffers::Offset<NegOptions> NegOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13654 return CreateNegOptions(_fbb, _o, _rehasher);
13655}
13656
13657inline flatbuffers::Offset<NegOptions> CreateNegOptions(flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13658 (void)_rehasher;
13659 (void)_o;
13660 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const NegOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13661 return tflite::CreateNegOptions(
13662 _fbb);
13663}
13664
13665inline SelectOptionsT *SelectOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13666 auto _o = new SelectOptionsT();
13667 UnPackTo(_o, _resolver);
13668 return _o;
13669}
13670
13671inline void SelectOptions::UnPackTo(SelectOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13672 (void)_o;
13673 (void)_resolver;
13674}
13675
13676inline flatbuffers::Offset<SelectOptions> SelectOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13677 return CreateSelectOptions(_fbb, _o, _rehasher);
13678}
13679
13680inline flatbuffers::Offset<SelectOptions> CreateSelectOptions(flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13681 (void)_rehasher;
13682 (void)_o;
13683 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SelectOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13684 return tflite::CreateSelectOptions(
13685 _fbb);
13686}
13687
13688inline SliceOptionsT *SliceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13689 auto _o = new SliceOptionsT();
13690 UnPackTo(_o, _resolver);
13691 return _o;
13692}
13693
13694inline void SliceOptions::UnPackTo(SliceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13695 (void)_o;
13696 (void)_resolver;
13697}
13698
13699inline flatbuffers::Offset<SliceOptions> SliceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13700 return CreateSliceOptions(_fbb, _o, _rehasher);
13701}
13702
13703inline flatbuffers::Offset<SliceOptions> CreateSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13704 (void)_rehasher;
13705 (void)_o;
13706 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SliceOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13707 return tflite::CreateSliceOptions(
13708 _fbb);
13709}
13710
13711inline TransposeConvOptionsT *TransposeConvOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13712 auto _o = new TransposeConvOptionsT();
13713 UnPackTo(_o, _resolver);
13714 return _o;
13715}
13716
13717inline void TransposeConvOptions::UnPackTo(TransposeConvOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13718 (void)_o;
13719 (void)_resolver;
13720 { auto _e = padding(); _o->padding = _e; }
13721 { auto _e = stride_w(); _o->stride_w = _e; }
13722 { auto _e = stride_h(); _o->stride_h = _e; }
13723}
13724
13725inline flatbuffers::Offset<TransposeConvOptions> TransposeConvOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13726 return CreateTransposeConvOptions(_fbb, _o, _rehasher);
13727}
13728
13729inline flatbuffers::Offset<TransposeConvOptions> CreateTransposeConvOptions(flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13730 (void)_rehasher;
13731 (void)_o;
13732 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TransposeConvOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13733 auto _padding = _o->padding;
13734 auto _stride_w = _o->stride_w;
13735 auto _stride_h = _o->stride_h;
13736 return tflite::CreateTransposeConvOptions(
13737 _fbb,
13738 _padding,
13739 _stride_w,
13740 _stride_h);
13741}
13742
13743inline ExpandDimsOptionsT *ExpandDimsOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13744 auto _o = new ExpandDimsOptionsT();
13745 UnPackTo(_o, _resolver);
13746 return _o;
13747}
13748
13749inline void ExpandDimsOptions::UnPackTo(ExpandDimsOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13750 (void)_o;
13751 (void)_resolver;
13752}
13753
13754inline flatbuffers::Offset<ExpandDimsOptions> ExpandDimsOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13755 return CreateExpandDimsOptions(_fbb, _o, _rehasher);
13756}
13757
13758inline flatbuffers::Offset<ExpandDimsOptions> CreateExpandDimsOptions(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13759 (void)_rehasher;
13760 (void)_o;
13761 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ExpandDimsOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13762 return tflite::CreateExpandDimsOptions(
13763 _fbb);
13764}
13765
13766inline SparseToDenseOptionsT *SparseToDenseOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13767 auto _o = new SparseToDenseOptionsT();
13768 UnPackTo(_o, _resolver);
13769 return _o;
13770}
13771
13772inline void SparseToDenseOptions::UnPackTo(SparseToDenseOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13773 (void)_o;
13774 (void)_resolver;
13775 { auto _e = validate_indices(); _o->validate_indices = _e; }
13776}
13777
13778inline flatbuffers::Offset<SparseToDenseOptions> SparseToDenseOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13779 return CreateSparseToDenseOptions(_fbb, _o, _rehasher);
13780}
13781
13782inline flatbuffers::Offset<SparseToDenseOptions> CreateSparseToDenseOptions(flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13783 (void)_rehasher;
13784 (void)_o;
13785 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SparseToDenseOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13786 auto _validate_indices = _o->validate_indices;
13787 return tflite::CreateSparseToDenseOptions(
13788 _fbb,
13789 _validate_indices);
13790}
13791
13792inline EqualOptionsT *EqualOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13793 auto _o = new EqualOptionsT();
13794 UnPackTo(_o, _resolver);
13795 return _o;
13796}
13797
13798inline void EqualOptions::UnPackTo(EqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13799 (void)_o;
13800 (void)_resolver;
13801}
13802
13803inline flatbuffers::Offset<EqualOptions> EqualOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13804 return CreateEqualOptions(_fbb, _o, _rehasher);
13805}
13806
13807inline flatbuffers::Offset<EqualOptions> CreateEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13808 (void)_rehasher;
13809 (void)_o;
13810 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const EqualOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13811 return tflite::CreateEqualOptions(
13812 _fbb);
13813}
13814
13815inline NotEqualOptionsT *NotEqualOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13816 auto _o = new NotEqualOptionsT();
13817 UnPackTo(_o, _resolver);
13818 return _o;
13819}
13820
13821inline void NotEqualOptions::UnPackTo(NotEqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13822 (void)_o;
13823 (void)_resolver;
13824}
13825
13826inline flatbuffers::Offset<NotEqualOptions> NotEqualOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13827 return CreateNotEqualOptions(_fbb, _o, _rehasher);
13828}
13829
13830inline flatbuffers::Offset<NotEqualOptions> CreateNotEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13831 (void)_rehasher;
13832 (void)_o;
13833 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const NotEqualOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13834 return tflite::CreateNotEqualOptions(
13835 _fbb);
13836}
13837
13838inline ShapeOptionsT *ShapeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13839 auto _o = new ShapeOptionsT();
13840 UnPackTo(_o, _resolver);
13841 return _o;
13842}
13843
13844inline void ShapeOptions::UnPackTo(ShapeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13845 (void)_o;
13846 (void)_resolver;
13847 { auto _e = out_type(); _o->out_type = _e; }
13848}
13849
13850inline flatbuffers::Offset<ShapeOptions> ShapeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13851 return CreateShapeOptions(_fbb, _o, _rehasher);
13852}
13853
13854inline flatbuffers::Offset<ShapeOptions> CreateShapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13855 (void)_rehasher;
13856 (void)_o;
13857 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ShapeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13858 auto _out_type = _o->out_type;
13859 return tflite::CreateShapeOptions(
13860 _fbb,
13861 _out_type);
13862}
13863
13864inline RankOptionsT *RankOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13865 auto _o = new RankOptionsT();
13866 UnPackTo(_o, _resolver);
13867 return _o;
13868}
13869
13870inline void RankOptions::UnPackTo(RankOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13871 (void)_o;
13872 (void)_resolver;
13873}
13874
13875inline flatbuffers::Offset<RankOptions> RankOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13876 return CreateRankOptions(_fbb, _o, _rehasher);
13877}
13878
13879inline flatbuffers::Offset<RankOptions> CreateRankOptions(flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13880 (void)_rehasher;
13881 (void)_o;
13882 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const RankOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13883 return tflite::CreateRankOptions(
13884 _fbb);
13885}
13886
13887inline PowOptionsT *PowOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13888 auto _o = new PowOptionsT();
13889 UnPackTo(_o, _resolver);
13890 return _o;
13891}
13892
13893inline void PowOptions::UnPackTo(PowOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13894 (void)_o;
13895 (void)_resolver;
13896}
13897
13898inline flatbuffers::Offset<PowOptions> PowOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13899 return CreatePowOptions(_fbb, _o, _rehasher);
13900}
13901
13902inline flatbuffers::Offset<PowOptions> CreatePowOptions(flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13903 (void)_rehasher;
13904 (void)_o;
13905 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PowOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13906 return tflite::CreatePowOptions(
13907 _fbb);
13908}
13909
13910inline FakeQuantOptionsT *FakeQuantOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13911 auto _o = new FakeQuantOptionsT();
13912 UnPackTo(_o, _resolver);
13913 return _o;
13914}
13915
13916inline void FakeQuantOptions::UnPackTo(FakeQuantOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13917 (void)_o;
13918 (void)_resolver;
13919 { auto _e = min(); _o->min = _e; }
13920 { auto _e = max(); _o->max = _e; }
13921 { auto _e = num_bits(); _o->num_bits = _e; }
13922 { auto _e = narrow_range(); _o->narrow_range = _e; }
13923}
13924
13925inline flatbuffers::Offset<FakeQuantOptions> FakeQuantOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13926 return CreateFakeQuantOptions(_fbb, _o, _rehasher);
13927}
13928
13929inline flatbuffers::Offset<FakeQuantOptions> CreateFakeQuantOptions(flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13930 (void)_rehasher;
13931 (void)_o;
13932 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FakeQuantOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13933 auto _min = _o->min;
13934 auto _max = _o->max;
13935 auto _num_bits = _o->num_bits;
13936 auto _narrow_range = _o->narrow_range;
13937 return tflite::CreateFakeQuantOptions(
13938 _fbb,
13939 _min,
13940 _max,
13941 _num_bits,
13942 _narrow_range);
13943}
13944
13945inline PackOptionsT *PackOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13946 auto _o = new PackOptionsT();
13947 UnPackTo(_o, _resolver);
13948 return _o;
13949}
13950
13951inline void PackOptions::UnPackTo(PackOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13952 (void)_o;
13953 (void)_resolver;
13954 { auto _e = values_count(); _o->values_count = _e; }
13955 { auto _e = axis(); _o->axis = _e; }
13956}
13957
13958inline flatbuffers::Offset<PackOptions> PackOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13959 return CreatePackOptions(_fbb, _o, _rehasher);
13960}
13961
13962inline flatbuffers::Offset<PackOptions> CreatePackOptions(flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13963 (void)_rehasher;
13964 (void)_o;
13965 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PackOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13966 auto _values_count = _o->values_count;
13967 auto _axis = _o->axis;
13968 return tflite::CreatePackOptions(
13969 _fbb,
13970 _values_count,
13971 _axis);
13972}
13973
13974inline LogicalOrOptionsT *LogicalOrOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13975 auto _o = new LogicalOrOptionsT();
13976 UnPackTo(_o, _resolver);
13977 return _o;
13978}
13979
13980inline void LogicalOrOptions::UnPackTo(LogicalOrOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13981 (void)_o;
13982 (void)_resolver;
13983}
13984
13985inline flatbuffers::Offset<LogicalOrOptions> LogicalOrOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13986 return CreateLogicalOrOptions(_fbb, _o, _rehasher);
13987}
13988
13989inline flatbuffers::Offset<LogicalOrOptions> CreateLogicalOrOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13990 (void)_rehasher;
13991 (void)_o;
13992 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LogicalOrOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13993 return tflite::CreateLogicalOrOptions(
13994 _fbb);
13995}
13996
13997inline OneHotOptionsT *OneHotOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13998 auto _o = new OneHotOptionsT();
13999 UnPackTo(_o, _resolver);
14000 return _o;
14001}
14002
14003inline void OneHotOptions::UnPackTo(OneHotOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14004 (void)_o;
14005 (void)_resolver;
14006 { auto _e = axis(); _o->axis = _e; }
14007}
14008
14009inline flatbuffers::Offset<OneHotOptions> OneHotOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14010 return CreateOneHotOptions(_fbb, _o, _rehasher);
14011}
14012
14013inline flatbuffers::Offset<OneHotOptions> CreateOneHotOptions(flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14014 (void)_rehasher;
14015 (void)_o;
14016 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const OneHotOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14017 auto _axis = _o->axis;
14018 return tflite::CreateOneHotOptions(
14019 _fbb,
14020 _axis);
14021}
14022
14023inline AbsOptionsT *AbsOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14024 auto _o = new AbsOptionsT();
14025 UnPackTo(_o, _resolver);
14026 return _o;
14027}
14028
14029inline void AbsOptions::UnPackTo(AbsOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14030 (void)_o;
14031 (void)_resolver;
14032}
14033
14034inline flatbuffers::Offset<AbsOptions> AbsOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14035 return CreateAbsOptions(_fbb, _o, _rehasher);
14036}
14037
14038inline flatbuffers::Offset<AbsOptions> CreateAbsOptions(flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14039 (void)_rehasher;
14040 (void)_o;
14041 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const AbsOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14042 return tflite::CreateAbsOptions(
14043 _fbb);
14044}
14045
14046inline HardSwishOptionsT *HardSwishOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14047 auto _o = new HardSwishOptionsT();
14048 UnPackTo(_o, _resolver);
14049 return _o;
14050}
14051
14052inline void HardSwishOptions::UnPackTo(HardSwishOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14053 (void)_o;
14054 (void)_resolver;
14055}
14056
14057inline flatbuffers::Offset<HardSwishOptions> HardSwishOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HardSwishOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14058 return CreateHardSwishOptions(_fbb, _o, _rehasher);
14059}
14060
14061inline flatbuffers::Offset<HardSwishOptions> CreateHardSwishOptions(flatbuffers::FlatBufferBuilder &_fbb, const HardSwishOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14062 (void)_rehasher;
14063 (void)_o;
14064 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const HardSwishOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14065 return tflite::CreateHardSwishOptions(
14066 _fbb);
14067}
14068
14069inline LogicalAndOptionsT *LogicalAndOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14070 auto _o = new LogicalAndOptionsT();
14071 UnPackTo(_o, _resolver);
14072 return _o;
14073}
14074
14075inline void LogicalAndOptions::UnPackTo(LogicalAndOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14076 (void)_o;
14077 (void)_resolver;
14078}
14079
14080inline flatbuffers::Offset<LogicalAndOptions> LogicalAndOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14081 return CreateLogicalAndOptions(_fbb, _o, _rehasher);
14082}
14083
14084inline flatbuffers::Offset<LogicalAndOptions> CreateLogicalAndOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14085 (void)_rehasher;
14086 (void)_o;
14087 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LogicalAndOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14088 return tflite::CreateLogicalAndOptions(
14089 _fbb);
14090}
14091
14092inline LogicalNotOptionsT *LogicalNotOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14093 auto _o = new LogicalNotOptionsT();
14094 UnPackTo(_o, _resolver);
14095 return _o;
14096}
14097
14098inline void LogicalNotOptions::UnPackTo(LogicalNotOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14099 (void)_o;
14100 (void)_resolver;
14101}
14102
14103inline flatbuffers::Offset<LogicalNotOptions> LogicalNotOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14104 return CreateLogicalNotOptions(_fbb, _o, _rehasher);
14105}
14106
14107inline flatbuffers::Offset<LogicalNotOptions> CreateLogicalNotOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14108 (void)_rehasher;
14109 (void)_o;
14110 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LogicalNotOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14111 return tflite::CreateLogicalNotOptions(
14112 _fbb);
14113}
14114
14115inline UnpackOptionsT *UnpackOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14116 auto _o = new UnpackOptionsT();
14117 UnPackTo(_o, _resolver);
14118 return _o;
14119}
14120
14121inline void UnpackOptions::UnPackTo(UnpackOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14122 (void)_o;
14123 (void)_resolver;
14124 { auto _e = num(); _o->num = _e; }
14125 { auto _e = axis(); _o->axis = _e; }
14126}
14127
14128inline flatbuffers::Offset<UnpackOptions> UnpackOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14129 return CreateUnpackOptions(_fbb, _o, _rehasher);
14130}
14131
14132inline flatbuffers::Offset<UnpackOptions> CreateUnpackOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14133 (void)_rehasher;
14134 (void)_o;
14135 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const UnpackOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14136 auto _num = _o->num;
14137 auto _axis = _o->axis;
14138 return tflite::CreateUnpackOptions(
14139 _fbb,
14140 _num,
14141 _axis);
14142}
14143
14144inline FloorDivOptionsT *FloorDivOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14145 auto _o = new FloorDivOptionsT();
14146 UnPackTo(_o, _resolver);
14147 return _o;
14148}
14149
14150inline void FloorDivOptions::UnPackTo(FloorDivOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14151 (void)_o;
14152 (void)_resolver;
14153}
14154
14155inline flatbuffers::Offset<FloorDivOptions> FloorDivOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14156 return CreateFloorDivOptions(_fbb, _o, _rehasher);
14157}
14158
14159inline flatbuffers::Offset<FloorDivOptions> CreateFloorDivOptions(flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14160 (void)_rehasher;
14161 (void)_o;
14162 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FloorDivOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14163 return tflite::CreateFloorDivOptions(
14164 _fbb);
14165}
14166
14167inline SquareOptionsT *SquareOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14168 auto _o = new SquareOptionsT();
14169 UnPackTo(_o, _resolver);
14170 return _o;
14171}
14172
14173inline void SquareOptions::UnPackTo(SquareOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14174 (void)_o;
14175 (void)_resolver;
14176}
14177
14178inline flatbuffers::Offset<SquareOptions> SquareOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14179 return CreateSquareOptions(_fbb, _o, _rehasher);
14180}
14181
14182inline flatbuffers::Offset<SquareOptions> CreateSquareOptions(flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14183 (void)_rehasher;
14184 (void)_o;
14185 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SquareOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14186 return tflite::CreateSquareOptions(
14187 _fbb);
14188}
14189
14190inline ZerosLikeOptionsT *ZerosLikeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14191 auto _o = new ZerosLikeOptionsT();
14192 UnPackTo(_o, _resolver);
14193 return _o;
14194}
14195
14196inline void ZerosLikeOptions::UnPackTo(ZerosLikeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14197 (void)_o;
14198 (void)_resolver;
14199}
14200
14201inline flatbuffers::Offset<ZerosLikeOptions> ZerosLikeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14202 return CreateZerosLikeOptions(_fbb, _o, _rehasher);
14203}
14204
14205inline flatbuffers::Offset<ZerosLikeOptions> CreateZerosLikeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14206 (void)_rehasher;
14207 (void)_o;
14208 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ZerosLikeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14209 return tflite::CreateZerosLikeOptions(
14210 _fbb);
14211}
14212
14213inline FillOptionsT *FillOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14214 auto _o = new FillOptionsT();
14215 UnPackTo(_o, _resolver);
14216 return _o;
14217}
14218
14219inline void FillOptions::UnPackTo(FillOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14220 (void)_o;
14221 (void)_resolver;
14222}
14223
14224inline flatbuffers::Offset<FillOptions> FillOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14225 return CreateFillOptions(_fbb, _o, _rehasher);
14226}
14227
14228inline flatbuffers::Offset<FillOptions> CreateFillOptions(flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14229 (void)_rehasher;
14230 (void)_o;
14231 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FillOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14232 return tflite::CreateFillOptions(
14233 _fbb);
14234}
14235
14236inline FloorModOptionsT *FloorModOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14237 auto _o = new FloorModOptionsT();
14238 UnPackTo(_o, _resolver);
14239 return _o;
14240}
14241
14242inline void FloorModOptions::UnPackTo(FloorModOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14243 (void)_o;
14244 (void)_resolver;
14245}
14246
14247inline flatbuffers::Offset<FloorModOptions> FloorModOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14248 return CreateFloorModOptions(_fbb, _o, _rehasher);
14249}
14250
14251inline flatbuffers::Offset<FloorModOptions> CreateFloorModOptions(flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14252 (void)_rehasher;
14253 (void)_o;
14254 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FloorModOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14255 return tflite::CreateFloorModOptions(
14256 _fbb);
14257}
14258
14259inline RangeOptionsT *RangeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14260 auto _o = new RangeOptionsT();
14261 UnPackTo(_o, _resolver);
14262 return _o;
14263}
14264
14265inline void RangeOptions::UnPackTo(RangeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14266 (void)_o;
14267 (void)_resolver;
14268}
14269
14270inline flatbuffers::Offset<RangeOptions> RangeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14271 return CreateRangeOptions(_fbb, _o, _rehasher);
14272}
14273
14274inline flatbuffers::Offset<RangeOptions> CreateRangeOptions(flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14275 (void)_rehasher;
14276 (void)_o;
14277 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const RangeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14278 return tflite::CreateRangeOptions(
14279 _fbb);
14280}
14281
14282inline LeakyReluOptionsT *LeakyReluOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14283 auto _o = new LeakyReluOptionsT();
14284 UnPackTo(_o, _resolver);
14285 return _o;
14286}
14287
14288inline void LeakyReluOptions::UnPackTo(LeakyReluOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14289 (void)_o;
14290 (void)_resolver;
14291 { auto _e = alpha(); _o->alpha = _e; }
14292}
14293
14294inline flatbuffers::Offset<LeakyReluOptions> LeakyReluOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14295 return CreateLeakyReluOptions(_fbb, _o, _rehasher);
14296}
14297
14298inline flatbuffers::Offset<LeakyReluOptions> CreateLeakyReluOptions(flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14299 (void)_rehasher;
14300 (void)_o;
14301 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LeakyReluOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14302 auto _alpha = _o->alpha;
14303 return tflite::CreateLeakyReluOptions(
14304 _fbb,
14305 _alpha);
14306}
14307
14308inline SquaredDifferenceOptionsT *SquaredDifferenceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14309 auto _o = new SquaredDifferenceOptionsT();
14310 UnPackTo(_o, _resolver);
14311 return _o;
14312}
14313
14314inline void SquaredDifferenceOptions::UnPackTo(SquaredDifferenceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14315 (void)_o;
14316 (void)_resolver;
14317}
14318
14319inline flatbuffers::Offset<SquaredDifferenceOptions> SquaredDifferenceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14320 return CreateSquaredDifferenceOptions(_fbb, _o, _rehasher);
14321}
14322
14323inline flatbuffers::Offset<SquaredDifferenceOptions> CreateSquaredDifferenceOptions(flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14324 (void)_rehasher;
14325 (void)_o;
14326 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SquaredDifferenceOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14327 return tflite::CreateSquaredDifferenceOptions(
14328 _fbb);
14329}
14330
14331inline MirrorPadOptionsT *MirrorPadOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14332 auto _o = new MirrorPadOptionsT();
14333 UnPackTo(_o, _resolver);
14334 return _o;
14335}
14336
14337inline void MirrorPadOptions::UnPackTo(MirrorPadOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14338 (void)_o;
14339 (void)_resolver;
14340 { auto _e = mode(); _o->mode = _e; }
14341}
14342
14343inline flatbuffers::Offset<MirrorPadOptions> MirrorPadOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14344 return CreateMirrorPadOptions(_fbb, _o, _rehasher);
14345}
14346
14347inline flatbuffers::Offset<MirrorPadOptions> CreateMirrorPadOptions(flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14348 (void)_rehasher;
14349 (void)_o;
14350 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MirrorPadOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14351 auto _mode = _o->mode;
14352 return tflite::CreateMirrorPadOptions(
14353 _fbb,
14354 _mode);
14355}
14356
14357inline UniqueOptionsT *UniqueOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14358 auto _o = new UniqueOptionsT();
14359 UnPackTo(_o, _resolver);
14360 return _o;
14361}
14362
14363inline void UniqueOptions::UnPackTo(UniqueOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14364 (void)_o;
14365 (void)_resolver;
14366 { auto _e = idx_out_type(); _o->idx_out_type = _e; }
14367}
14368
14369inline flatbuffers::Offset<UniqueOptions> UniqueOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14370 return CreateUniqueOptions(_fbb, _o, _rehasher);
14371}
14372
14373inline flatbuffers::Offset<UniqueOptions> CreateUniqueOptions(flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14374 (void)_rehasher;
14375 (void)_o;
14376 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const UniqueOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14377 auto _idx_out_type = _o->idx_out_type;
14378 return tflite::CreateUniqueOptions(
14379 _fbb,
14380 _idx_out_type);
14381}
14382
14383inline ReverseV2OptionsT *ReverseV2Options::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14384 auto _o = new ReverseV2OptionsT();
14385 UnPackTo(_o, _resolver);
14386 return _o;
14387}
14388
14389inline void ReverseV2Options::UnPackTo(ReverseV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14390 (void)_o;
14391 (void)_resolver;
14392}
14393
14394inline flatbuffers::Offset<ReverseV2Options> ReverseV2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14395 return CreateReverseV2Options(_fbb, _o, _rehasher);
14396}
14397
14398inline flatbuffers::Offset<ReverseV2Options> CreateReverseV2Options(flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14399 (void)_rehasher;
14400 (void)_o;
14401 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ReverseV2OptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14402 return tflite::CreateReverseV2Options(
14403 _fbb);
14404}
14405
14406inline AddNOptionsT *AddNOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14407 auto _o = new AddNOptionsT();
14408 UnPackTo(_o, _resolver);
14409 return _o;
14410}
14411
14412inline void AddNOptions::UnPackTo(AddNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14413 (void)_o;
14414 (void)_resolver;
14415}
14416
14417inline flatbuffers::Offset<AddNOptions> AddNOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14418 return CreateAddNOptions(_fbb, _o, _rehasher);
14419}
14420
14421inline flatbuffers::Offset<AddNOptions> CreateAddNOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14422 (void)_rehasher;
14423 (void)_o;
14424 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const AddNOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14425 return tflite::CreateAddNOptions(
14426 _fbb);
14427}
14428
14429inline GatherNdOptionsT *GatherNdOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14430 auto _o = new GatherNdOptionsT();
14431 UnPackTo(_o, _resolver);
14432 return _o;
14433}
14434
14435inline void GatherNdOptions::UnPackTo(GatherNdOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14436 (void)_o;
14437 (void)_resolver;
14438}
14439
14440inline flatbuffers::Offset<GatherNdOptions> GatherNdOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14441 return CreateGatherNdOptions(_fbb, _o, _rehasher);
14442}
14443
14444inline flatbuffers::Offset<GatherNdOptions> CreateGatherNdOptions(flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14445 (void)_rehasher;
14446 (void)_o;
14447 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const GatherNdOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14448 return tflite::CreateGatherNdOptions(
14449 _fbb);
14450}
14451
14452inline WhereOptionsT *WhereOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14453 auto _o = new WhereOptionsT();
14454 UnPackTo(_o, _resolver);
14455 return _o;
14456}
14457
14458inline void WhereOptions::UnPackTo(WhereOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14459 (void)_o;
14460 (void)_resolver;
14461}
14462
14463inline flatbuffers::Offset<WhereOptions> WhereOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14464 return CreateWhereOptions(_fbb, _o, _rehasher);
14465}
14466
14467inline flatbuffers::Offset<WhereOptions> CreateWhereOptions(flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14468 (void)_rehasher;
14469 (void)_o;
14470 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const WhereOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14471 return tflite::CreateWhereOptions(
14472 _fbb);
14473}
14474
14475inline ReverseSequenceOptionsT *ReverseSequenceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14476 auto _o = new ReverseSequenceOptionsT();
14477 UnPackTo(_o, _resolver);
14478 return _o;
14479}
14480
14481inline void ReverseSequenceOptions::UnPackTo(ReverseSequenceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14482 (void)_o;
14483 (void)_resolver;
14484 { auto _e = seq_dim(); _o->seq_dim = _e; }
14485 { auto _e = batch_dim(); _o->batch_dim = _e; }
14486}
14487
14488inline flatbuffers::Offset<ReverseSequenceOptions> ReverseSequenceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14489 return CreateReverseSequenceOptions(_fbb, _o, _rehasher);
14490}
14491
14492inline flatbuffers::Offset<ReverseSequenceOptions> CreateReverseSequenceOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14493 (void)_rehasher;
14494 (void)_o;
14495 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ReverseSequenceOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14496 auto _seq_dim = _o->seq_dim;
14497 auto _batch_dim = _o->batch_dim;
14498 return tflite::CreateReverseSequenceOptions(
14499 _fbb,
14500 _seq_dim,
14501 _batch_dim);
14502}
14503
14504inline MatrixDiagOptionsT *MatrixDiagOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14505 auto _o = new MatrixDiagOptionsT();
14506 UnPackTo(_o, _resolver);
14507 return _o;
14508}
14509
14510inline void MatrixDiagOptions::UnPackTo(MatrixDiagOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14511 (void)_o;
14512 (void)_resolver;
14513}
14514
14515inline flatbuffers::Offset<MatrixDiagOptions> MatrixDiagOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatrixDiagOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14516 return CreateMatrixDiagOptions(_fbb, _o, _rehasher);
14517}
14518
14519inline flatbuffers::Offset<MatrixDiagOptions> CreateMatrixDiagOptions(flatbuffers::FlatBufferBuilder &_fbb, const MatrixDiagOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14520 (void)_rehasher;
14521 (void)_o;
14522 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MatrixDiagOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14523 return tflite::CreateMatrixDiagOptions(
14524 _fbb);
14525}
14526
14527inline QuantizeOptionsT *QuantizeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14528 auto _o = new QuantizeOptionsT();
14529 UnPackTo(_o, _resolver);
14530 return _o;
14531}
14532
14533inline void QuantizeOptions::UnPackTo(QuantizeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14534 (void)_o;
14535 (void)_resolver;
14536}
14537
14538inline flatbuffers::Offset<QuantizeOptions> QuantizeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14539 return CreateQuantizeOptions(_fbb, _o, _rehasher);
14540}
14541
14542inline flatbuffers::Offset<QuantizeOptions> CreateQuantizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14543 (void)_rehasher;
14544 (void)_o;
14545 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const QuantizeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14546 return tflite::CreateQuantizeOptions(
14547 _fbb);
14548}
14549
14550inline MatrixSetDiagOptionsT *MatrixSetDiagOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14551 auto _o = new MatrixSetDiagOptionsT();
14552 UnPackTo(_o, _resolver);
14553 return _o;
14554}
14555
14556inline void MatrixSetDiagOptions::UnPackTo(MatrixSetDiagOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14557 (void)_o;
14558 (void)_resolver;
14559}
14560
14561inline flatbuffers::Offset<MatrixSetDiagOptions> MatrixSetDiagOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatrixSetDiagOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14562 return CreateMatrixSetDiagOptions(_fbb, _o, _rehasher);
14563}
14564
14565inline flatbuffers::Offset<MatrixSetDiagOptions> CreateMatrixSetDiagOptions(flatbuffers::FlatBufferBuilder &_fbb, const MatrixSetDiagOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14566 (void)_rehasher;
14567 (void)_o;
14568 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MatrixSetDiagOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14569 return tflite::CreateMatrixSetDiagOptions(
14570 _fbb);
14571}
14572
14573inline IfOptionsT *IfOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14574 auto _o = new IfOptionsT();
14575 UnPackTo(_o, _resolver);
14576 return _o;
14577}
14578
14579inline void IfOptions::UnPackTo(IfOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14580 (void)_o;
14581 (void)_resolver;
14582 { auto _e = then_subgraph_index(); _o->then_subgraph_index = _e; }
14583 { auto _e = else_subgraph_index(); _o->else_subgraph_index = _e; }
14584}
14585
14586inline flatbuffers::Offset<IfOptions> IfOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const IfOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14587 return CreateIfOptions(_fbb, _o, _rehasher);
14588}
14589
14590inline flatbuffers::Offset<IfOptions> CreateIfOptions(flatbuffers::FlatBufferBuilder &_fbb, const IfOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14591 (void)_rehasher;
14592 (void)_o;
14593 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const IfOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14594 auto _then_subgraph_index = _o->then_subgraph_index;
14595 auto _else_subgraph_index = _o->else_subgraph_index;
14596 return tflite::CreateIfOptions(
14597 _fbb,
14598 _then_subgraph_index,
14599 _else_subgraph_index);
14600}
14601
14602inline CallOnceOptionsT *CallOnceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14603 auto _o = new CallOnceOptionsT();
14604 UnPackTo(_o, _resolver);
14605 return _o;
14606}
14607
14608inline void CallOnceOptions::UnPackTo(CallOnceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14609 (void)_o;
14610 (void)_resolver;
14611 { auto _e = init_subgraph_index(); _o->init_subgraph_index = _e; }
14612}
14613
14614inline flatbuffers::Offset<CallOnceOptions> CallOnceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CallOnceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14615 return CreateCallOnceOptions(_fbb, _o, _rehasher);
14616}
14617
14618inline flatbuffers::Offset<CallOnceOptions> CreateCallOnceOptions(flatbuffers::FlatBufferBuilder &_fbb, const CallOnceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14619 (void)_rehasher;
14620 (void)_o;
14621 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const CallOnceOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14622 auto _init_subgraph_index = _o->init_subgraph_index;
14623 return tflite::CreateCallOnceOptions(
14624 _fbb,
14625 _init_subgraph_index);
14626}
14627
14628inline WhileOptionsT *WhileOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14629 auto _o = new WhileOptionsT();
14630 UnPackTo(_o, _resolver);
14631 return _o;
14632}
14633
14634inline void WhileOptions::UnPackTo(WhileOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14635 (void)_o;
14636 (void)_resolver;
14637 { auto _e = cond_subgraph_index(); _o->cond_subgraph_index = _e; }
14638 { auto _e = body_subgraph_index(); _o->body_subgraph_index = _e; }
14639}
14640
14641inline flatbuffers::Offset<WhileOptions> WhileOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const WhileOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14642 return CreateWhileOptions(_fbb, _o, _rehasher);
14643}
14644
14645inline flatbuffers::Offset<WhileOptions> CreateWhileOptions(flatbuffers::FlatBufferBuilder &_fbb, const WhileOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14646 (void)_rehasher;
14647 (void)_o;
14648 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const WhileOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14649 auto _cond_subgraph_index = _o->cond_subgraph_index;
14650 auto _body_subgraph_index = _o->body_subgraph_index;
14651 return tflite::CreateWhileOptions(
14652 _fbb,
14653 _cond_subgraph_index,
14654 _body_subgraph_index);
14655}
14656
14657inline NonMaxSuppressionV4OptionsT *NonMaxSuppressionV4Options::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14658 auto _o = new NonMaxSuppressionV4OptionsT();
14659 UnPackTo(_o, _resolver);
14660 return _o;
14661}
14662
14663inline void NonMaxSuppressionV4Options::UnPackTo(NonMaxSuppressionV4OptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14664 (void)_o;
14665 (void)_resolver;
14666}
14667
14668inline flatbuffers::Offset<NonMaxSuppressionV4Options> NonMaxSuppressionV4Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV4OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14669 return CreateNonMaxSuppressionV4Options(_fbb, _o, _rehasher);
14670}
14671
14672inline flatbuffers::Offset<NonMaxSuppressionV4Options> CreateNonMaxSuppressionV4Options(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV4OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14673 (void)_rehasher;
14674 (void)_o;
14675 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const NonMaxSuppressionV4OptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14676 return tflite::CreateNonMaxSuppressionV4Options(
14677 _fbb);
14678}
14679
14680inline NonMaxSuppressionV5OptionsT *NonMaxSuppressionV5Options::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14681 auto _o = new NonMaxSuppressionV5OptionsT();
14682 UnPackTo(_o, _resolver);
14683 return _o;
14684}
14685
14686inline void NonMaxSuppressionV5Options::UnPackTo(NonMaxSuppressionV5OptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14687 (void)_o;
14688 (void)_resolver;
14689}
14690
14691inline flatbuffers::Offset<NonMaxSuppressionV5Options> NonMaxSuppressionV5Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV5OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14692 return CreateNonMaxSuppressionV5Options(_fbb, _o, _rehasher);
14693}
14694
14695inline flatbuffers::Offset<NonMaxSuppressionV5Options> CreateNonMaxSuppressionV5Options(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV5OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14696 (void)_rehasher;
14697 (void)_o;
14698 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const NonMaxSuppressionV5OptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14699 return tflite::CreateNonMaxSuppressionV5Options(
14700 _fbb);
14701}
14702
14703inline ScatterNdOptionsT *ScatterNdOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14704 auto _o = new ScatterNdOptionsT();
14705 UnPackTo(_o, _resolver);
14706 return _o;
14707}
14708
14709inline void ScatterNdOptions::UnPackTo(ScatterNdOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14710 (void)_o;
14711 (void)_resolver;
14712}
14713
14714inline flatbuffers::Offset<ScatterNdOptions> ScatterNdOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ScatterNdOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14715 return CreateScatterNdOptions(_fbb, _o, _rehasher);
14716}
14717
14718inline flatbuffers::Offset<ScatterNdOptions> CreateScatterNdOptions(flatbuffers::FlatBufferBuilder &_fbb, const ScatterNdOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14719 (void)_rehasher;
14720 (void)_o;
14721 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ScatterNdOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14722 return tflite::CreateScatterNdOptions(
14723 _fbb);
14724}
14725
14726inline SelectV2OptionsT *SelectV2Options::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14727 auto _o = new SelectV2OptionsT();
14728 UnPackTo(_o, _resolver);
14729 return _o;
14730}
14731
14732inline void SelectV2Options::UnPackTo(SelectV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14733 (void)_o;
14734 (void)_resolver;
14735}
14736
14737inline flatbuffers::Offset<SelectV2Options> SelectV2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelectV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14738 return CreateSelectV2Options(_fbb, _o, _rehasher);
14739}
14740
14741inline flatbuffers::Offset<SelectV2Options> CreateSelectV2Options(flatbuffers::FlatBufferBuilder &_fbb, const SelectV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14742 (void)_rehasher;
14743 (void)_o;
14744 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SelectV2OptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14745 return tflite::CreateSelectV2Options(
14746 _fbb);
14747}
14748
14749inline DensifyOptionsT *DensifyOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14750 auto _o = new DensifyOptionsT();
14751 UnPackTo(_o, _resolver);
14752 return _o;
14753}
14754
14755inline void DensifyOptions::UnPackTo(DensifyOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14756 (void)_o;
14757 (void)_resolver;
14758}
14759
14760inline flatbuffers::Offset<DensifyOptions> DensifyOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DensifyOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14761 return CreateDensifyOptions(_fbb, _o, _rehasher);
14762}
14763
14764inline flatbuffers::Offset<DensifyOptions> CreateDensifyOptions(flatbuffers::FlatBufferBuilder &_fbb, const DensifyOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14765 (void)_rehasher;
14766 (void)_o;
14767 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DensifyOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14768 return tflite::CreateDensifyOptions(
14769 _fbb);
14770}
14771
14772inline SegmentSumOptionsT *SegmentSumOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14773 auto _o = new SegmentSumOptionsT();
14774 UnPackTo(_o, _resolver);
14775 return _o;
14776}
14777
14778inline void SegmentSumOptions::UnPackTo(SegmentSumOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14779 (void)_o;
14780 (void)_resolver;
14781}
14782
14783inline flatbuffers::Offset<SegmentSumOptions> SegmentSumOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SegmentSumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14784 return CreateSegmentSumOptions(_fbb, _o, _rehasher);
14785}
14786
14787inline flatbuffers::Offset<SegmentSumOptions> CreateSegmentSumOptions(flatbuffers::FlatBufferBuilder &_fbb, const SegmentSumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14788 (void)_rehasher;
14789 (void)_o;
14790 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SegmentSumOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14791 return tflite::CreateSegmentSumOptions(
14792 _fbb);
14793}
14794
14795inline BatchMatMulOptionsT *BatchMatMulOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14796 auto _o = new BatchMatMulOptionsT();
14797 UnPackTo(_o, _resolver);
14798 return _o;
14799}
14800
14801inline void BatchMatMulOptions::UnPackTo(BatchMatMulOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14802 (void)_o;
14803 (void)_resolver;
14804 { auto _e = adj_x(); _o->adj_x = _e; }
14805 { auto _e = adj_y(); _o->adj_y = _e; }
14806 { auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
14807}
14808
14809inline flatbuffers::Offset<BatchMatMulOptions> BatchMatMulOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BatchMatMulOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14810 return CreateBatchMatMulOptions(_fbb, _o, _rehasher);
14811}
14812
14813inline flatbuffers::Offset<BatchMatMulOptions> CreateBatchMatMulOptions(flatbuffers::FlatBufferBuilder &_fbb, const BatchMatMulOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14814 (void)_rehasher;
14815 (void)_o;
14816 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BatchMatMulOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14817 auto _adj_x = _o->adj_x;
14818 auto _adj_y = _o->adj_y;
14819 auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
14820 return tflite::CreateBatchMatMulOptions(
14821 _fbb,
14822 _adj_x,
14823 _adj_y,
14824 _asymmetric_quantize_inputs);
14825}
14826
14827inline CumsumOptionsT *CumsumOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14828 auto _o = new CumsumOptionsT();
14829 UnPackTo(_o, _resolver);
14830 return _o;
14831}
14832
14833inline void CumsumOptions::UnPackTo(CumsumOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14834 (void)_o;
14835 (void)_resolver;
14836 { auto _e = exclusive(); _o->exclusive = _e; }
14837 { auto _e = reverse(); _o->reverse = _e; }
14838}
14839
14840inline flatbuffers::Offset<CumsumOptions> CumsumOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CumsumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14841 return CreateCumsumOptions(_fbb, _o, _rehasher);
14842}
14843
14844inline flatbuffers::Offset<CumsumOptions> CreateCumsumOptions(flatbuffers::FlatBufferBuilder &_fbb, const CumsumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14845 (void)_rehasher;
14846 (void)_o;
14847 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const CumsumOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14848 auto _exclusive = _o->exclusive;
14849 auto _reverse = _o->reverse;
14850 return tflite::CreateCumsumOptions(
14851 _fbb,
14852 _exclusive,
14853 _reverse);
14854}
14855
14856inline BroadcastToOptionsT *BroadcastToOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14857 auto _o = new BroadcastToOptionsT();
14858 UnPackTo(_o, _resolver);
14859 return _o;
14860}
14861
14862inline void BroadcastToOptions::UnPackTo(BroadcastToOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14863 (void)_o;
14864 (void)_resolver;
14865}
14866
14867inline flatbuffers::Offset<BroadcastToOptions> BroadcastToOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BroadcastToOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14868 return CreateBroadcastToOptions(_fbb, _o, _rehasher);
14869}
14870
14871inline flatbuffers::Offset<BroadcastToOptions> CreateBroadcastToOptions(flatbuffers::FlatBufferBuilder &_fbb, const BroadcastToOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14872 (void)_rehasher;
14873 (void)_o;
14874 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BroadcastToOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14875 return tflite::CreateBroadcastToOptions(
14876 _fbb);
14877}
14878
14879inline Rfft2dOptionsT *Rfft2dOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14880 auto _o = new Rfft2dOptionsT();
14881 UnPackTo(_o, _resolver);
14882 return _o;
14883}
14884
14885inline void Rfft2dOptions::UnPackTo(Rfft2dOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14886 (void)_o;
14887 (void)_resolver;
14888}
14889
14890inline flatbuffers::Offset<Rfft2dOptions> Rfft2dOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Rfft2dOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14891 return CreateRfft2dOptions(_fbb, _o, _rehasher);
14892}
14893
14894inline flatbuffers::Offset<Rfft2dOptions> CreateRfft2dOptions(flatbuffers::FlatBufferBuilder &_fbb, const Rfft2dOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14895 (void)_rehasher;
14896 (void)_o;
14897 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const Rfft2dOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14898 return tflite::CreateRfft2dOptions(
14899 _fbb);
14900}
14901
14902inline HashtableOptionsT *HashtableOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14903 auto _o = new HashtableOptionsT();
14904 UnPackTo(_o, _resolver);
14905 return _o;
14906}
14907
14908inline void HashtableOptions::UnPackTo(HashtableOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14909 (void)_o;
14910 (void)_resolver;
14911 { auto _e = table_id(); _o->table_id = _e; }
14912 { auto _e = key_dtype(); _o->key_dtype = _e; }
14913 { auto _e = value_dtype(); _o->value_dtype = _e; }
14914}
14915
14916inline flatbuffers::Offset<HashtableOptions> HashtableOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14917 return CreateHashtableOptions(_fbb, _o, _rehasher);
14918}
14919
14920inline flatbuffers::Offset<HashtableOptions> CreateHashtableOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14921 (void)_rehasher;
14922 (void)_o;
14923 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const HashtableOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14924 auto _table_id = _o->table_id;
14925 auto _key_dtype = _o->key_dtype;
14926 auto _value_dtype = _o->value_dtype;
14927 return tflite::CreateHashtableOptions(
14928 _fbb,
14929 _table_id,
14930 _key_dtype,
14931 _value_dtype);
14932}
14933
14934inline HashtableFindOptionsT *HashtableFindOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14935 auto _o = new HashtableFindOptionsT();
14936 UnPackTo(_o, _resolver);
14937 return _o;
14938}
14939
14940inline void HashtableFindOptions::UnPackTo(HashtableFindOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14941 (void)_o;
14942 (void)_resolver;
14943}
14944
14945inline flatbuffers::Offset<HashtableFindOptions> HashtableFindOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableFindOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14946 return CreateHashtableFindOptions(_fbb, _o, _rehasher);
14947}
14948
14949inline flatbuffers::Offset<HashtableFindOptions> CreateHashtableFindOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableFindOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14950 (void)_rehasher;
14951 (void)_o;
14952 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const HashtableFindOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14953 return tflite::CreateHashtableFindOptions(
14954 _fbb);
14955}
14956
14957inline HashtableImportOptionsT *HashtableImportOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14958 auto _o = new HashtableImportOptionsT();
14959 UnPackTo(_o, _resolver);
14960 return _o;
14961}
14962
14963inline void HashtableImportOptions::UnPackTo(HashtableImportOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14964 (void)_o;
14965 (void)_resolver;
14966}
14967
14968inline flatbuffers::Offset<HashtableImportOptions> HashtableImportOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableImportOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14969 return CreateHashtableImportOptions(_fbb, _o, _rehasher);
14970}
14971
14972inline flatbuffers::Offset<HashtableImportOptions> CreateHashtableImportOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableImportOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14973 (void)_rehasher;
14974 (void)_o;
14975 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const HashtableImportOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14976 return tflite::CreateHashtableImportOptions(
14977 _fbb);
14978}
14979
14980inline HashtableSizeOptionsT *HashtableSizeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14981 auto _o = new HashtableSizeOptionsT();
14982 UnPackTo(_o, _resolver);
14983 return _o;
14984}
14985
14986inline void HashtableSizeOptions::UnPackTo(HashtableSizeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14987 (void)_o;
14988 (void)_resolver;
14989}
14990
14991inline flatbuffers::Offset<HashtableSizeOptions> HashtableSizeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableSizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14992 return CreateHashtableSizeOptions(_fbb, _o, _rehasher);
14993}
14994
14995inline flatbuffers::Offset<HashtableSizeOptions> CreateHashtableSizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableSizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14996 (void)_rehasher;
14997 (void)_o;
14998 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const HashtableSizeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14999 return tflite::CreateHashtableSizeOptions(
15000 _fbb);
15001}
15002
15003inline OperatorCodeT *OperatorCode::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15004 auto _o = new OperatorCodeT();
15005 UnPackTo(_o, _resolver);
15006 return _o;
15007}
15008
15009inline void OperatorCode::UnPackTo(OperatorCodeT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15010 (void)_o;
15011 (void)_resolver;
15012 { auto _e = deprecated_builtin_code(); _o->deprecated_builtin_code = _e; }
15013 { auto _e = custom_code(); if (_e) _o->custom_code = _e->str(); }
15014 { auto _e = version(); _o->version = _e; }
15015 { auto _e = builtin_code(); _o->builtin_code = _e; }
15016}
15017
15018inline flatbuffers::Offset<OperatorCode> OperatorCode::Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15019 return CreateOperatorCode(_fbb, _o, _rehasher);
15020}
15021
15022inline flatbuffers::Offset<OperatorCode> CreateOperatorCode(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15023 (void)_rehasher;
15024 (void)_o;
15025 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const OperatorCodeT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15026 auto _deprecated_builtin_code = _o->deprecated_builtin_code;
15027 auto _custom_code = _o->custom_code.empty() ? 0 : _fbb.CreateString(_o->custom_code);
15028 auto _version = _o->version;
15029 auto _builtin_code = _o->builtin_code;
15030 return tflite::CreateOperatorCode(
15031 _fbb,
15032 _deprecated_builtin_code,
15033 _custom_code,
15034 _version,
15035 _builtin_code);
15036}
15037
15038inline OperatorT *Operator::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15039 auto _o = new OperatorT();
15040 UnPackTo(_o, _resolver);
15041 return _o;
15042}
15043
15044inline void Operator::UnPackTo(OperatorT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15045 (void)_o;
15046 (void)_resolver;
15047 { auto _e = opcode_index(); _o->opcode_index = _e; }
15048 { auto _e = inputs(); if (_e) { _o->inputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->inputs[_i] = _e->Get(_i); } } }
15049 { auto _e = outputs(); if (_e) { _o->outputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->outputs[_i] = _e->Get(_i); } } }
15050 { auto _e = builtin_options_type(); _o->builtin_options.type = _e; }
15051 { auto _e = builtin_options(); if (_e) _o->builtin_options.value = tflite::BuiltinOptionsUnion::UnPack(_e, builtin_options_type(), _resolver); }
15052 { auto _e = custom_options(); if (_e) { _o->custom_options.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->custom_options.begin()); } }
15053 { auto _e = custom_options_format(); _o->custom_options_format = _e; }
15054 { auto _e = mutating_variable_inputs(); if (_e) { _o->mutating_variable_inputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->mutating_variable_inputs[_i] = _e->Get(_i) != 0; } } }
15055 { auto _e = intermediates(); if (_e) { _o->intermediates.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->intermediates[_i] = _e->Get(_i); } } }
15056}
15057
15058inline flatbuffers::Offset<Operator> Operator::Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15059 return CreateOperator(_fbb, _o, _rehasher);
15060}
15061
15062inline flatbuffers::Offset<Operator> CreateOperator(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15063 (void)_rehasher;
15064 (void)_o;
15065 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const OperatorT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15066 auto _opcode_index = _o->opcode_index;
15067 auto _inputs = _o->inputs.size() ? _fbb.CreateVector(_o->inputs) : 0;
15068 auto _outputs = _o->outputs.size() ? _fbb.CreateVector(_o->outputs) : 0;
15069 auto _builtin_options_type = _o->builtin_options.type;
15070 auto _builtin_options = _o->builtin_options.Pack(_fbb);
15071 auto _custom_options = _o->custom_options.size() ? _fbb.CreateVector(_o->custom_options) : 0;
15072 auto _custom_options_format = _o->custom_options_format;
15073 auto _mutating_variable_inputs = _o->mutating_variable_inputs.size() ? _fbb.CreateVector(_o->mutating_variable_inputs) : 0;
15074 auto _intermediates = _o->intermediates.size() ? _fbb.CreateVector(_o->intermediates) : 0;
15075 return tflite::CreateOperator(
15076 _fbb,
15077 _opcode_index,
15078 _inputs,
15079 _outputs,
15080 _builtin_options_type,
15081 _builtin_options,
15082 _custom_options,
15083 _custom_options_format,
15084 _mutating_variable_inputs,
15085 _intermediates);
15086}
15087
15088inline SubGraphT *SubGraph::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15089 auto _o = new SubGraphT();
15090 UnPackTo(_o, _resolver);
15091 return _o;
15092}
15093
15094inline void SubGraph::UnPackTo(SubGraphT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15095 (void)_o;
15096 (void)_resolver;
15097 { auto _e = tensors(); if (_e) { _o->tensors.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->tensors[_i] = std::unique_ptr<tflite::TensorT>(_e->Get(_i)->UnPack(_resolver)); } } }
15098 { auto _e = inputs(); if (_e) { _o->inputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->inputs[_i] = _e->Get(_i); } } }
15099 { auto _e = outputs(); if (_e) { _o->outputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->outputs[_i] = _e->Get(_i); } } }
15100 { auto _e = operators(); if (_e) { _o->operators.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->operators[_i] = std::unique_ptr<tflite::OperatorT>(_e->Get(_i)->UnPack(_resolver)); } } }
15101 { auto _e = name(); if (_e) _o->name = _e->str(); }
15102}
15103
15104inline flatbuffers::Offset<SubGraph> SubGraph::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15105 return CreateSubGraph(_fbb, _o, _rehasher);
15106}
15107
15108inline flatbuffers::Offset<SubGraph> CreateSubGraph(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15109 (void)_rehasher;
15110 (void)_o;
15111 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SubGraphT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15112 auto _tensors = _o->tensors.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::Tensor>> (_o->tensors.size(), [](size_t i, _VectorArgs *__va) { return CreateTensor(*__va->__fbb, __va->__o->tensors[i].get(), __va->__rehasher); }, &_va ) : 0;
15113 auto _inputs = _o->inputs.size() ? _fbb.CreateVector(_o->inputs) : 0;
15114 auto _outputs = _o->outputs.size() ? _fbb.CreateVector(_o->outputs) : 0;
15115 auto _operators = _o->operators.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::Operator>> (_o->operators.size(), [](size_t i, _VectorArgs *__va) { return CreateOperator(*__va->__fbb, __va->__o->operators[i].get(), __va->__rehasher); }, &_va ) : 0;
15116 auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name);
15117 return tflite::CreateSubGraph(
15118 _fbb,
15119 _tensors,
15120 _inputs,
15121 _outputs,
15122 _operators,
15123 _name);
15124}
15125
15126inline BufferT *Buffer::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15127 auto _o = new BufferT();
15128 UnPackTo(_o, _resolver);
15129 return _o;
15130}
15131
15132inline void Buffer::UnPackTo(BufferT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15133 (void)_o;
15134 (void)_resolver;
15135 { auto _e = data(); if (_e) { _o->data.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->data.begin()); } }
15136}
15137
15138inline flatbuffers::Offset<Buffer> Buffer::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BufferT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15139 return CreateBuffer(_fbb, _o, _rehasher);
15140}
15141
15142inline flatbuffers::Offset<Buffer> CreateBuffer(flatbuffers::FlatBufferBuilder &_fbb, const BufferT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15143 (void)_rehasher;
15144 (void)_o;
15145 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BufferT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15146 _fbb.ForceVectorAlignment(_o->data.size(), sizeof(uint8_t), 16);
15147 auto _data = _o->data.size() ? _fbb.CreateVector(_o->data) : 0;
15148 return tflite::CreateBuffer(
15149 _fbb,
15150 _data);
15151}
15152
15153inline MetadataT *Metadata::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15154 auto _o = new MetadataT();
15155 UnPackTo(_o, _resolver);
15156 return _o;
15157}
15158
15159inline void Metadata::UnPackTo(MetadataT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15160 (void)_o;
15161 (void)_resolver;
15162 { auto _e = name(); if (_e) _o->name = _e->str(); }
15163 { auto _e = buffer(); _o->buffer = _e; }
15164}
15165
15166inline flatbuffers::Offset<Metadata> Metadata::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15167 return CreateMetadata(_fbb, _o, _rehasher);
15168}
15169
15170inline flatbuffers::Offset<Metadata> CreateMetadata(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15171 (void)_rehasher;
15172 (void)_o;
15173 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MetadataT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15174 auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name);
15175 auto _buffer = _o->buffer;
15176 return tflite::CreateMetadata(
15177 _fbb,
15178 _name,
15179 _buffer);
15180}
15181
15182inline TensorMapT *TensorMap::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15183 auto _o = new TensorMapT();
15184 UnPackTo(_o, _resolver);
15185 return _o;
15186}
15187
15188inline void TensorMap::UnPackTo(TensorMapT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15189 (void)_o;
15190 (void)_resolver;
15191 { auto _e = name(); if (_e) _o->name = _e->str(); }
15192 { auto _e = tensor_index(); _o->tensor_index = _e; }
15193}
15194
15195inline flatbuffers::Offset<TensorMap> TensorMap::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorMapT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15196 return CreateTensorMap(_fbb, _o, _rehasher);
15197}
15198
15199inline flatbuffers::Offset<TensorMap> CreateTensorMap(flatbuffers::FlatBufferBuilder &_fbb, const TensorMapT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15200 (void)_rehasher;
15201 (void)_o;
15202 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TensorMapT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15203 auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name);
15204 auto _tensor_index = _o->tensor_index;
15205 return tflite::CreateTensorMap(
15206 _fbb,
15207 _name,
15208 _tensor_index);
15209}
15210
15211inline SignatureDefT *SignatureDef::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15212 auto _o = new SignatureDefT();
15213 UnPackTo(_o, _resolver);
15214 return _o;
15215}
15216
15217inline void SignatureDef::UnPackTo(SignatureDefT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15218 (void)_o;
15219 (void)_resolver;
15220 { auto _e = inputs(); if (_e) { _o->inputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->inputs[_i] = std::unique_ptr<tflite::TensorMapT>(_e->Get(_i)->UnPack(_resolver)); } } }
15221 { auto _e = outputs(); if (_e) { _o->outputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->outputs[_i] = std::unique_ptr<tflite::TensorMapT>(_e->Get(_i)->UnPack(_resolver)); } } }
15222 { auto _e = method_name(); if (_e) _o->method_name = _e->str(); }
15223 { auto _e = key(); if (_e) _o->key = _e->str(); }
15224}
15225
15226inline flatbuffers::Offset<SignatureDef> SignatureDef::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SignatureDefT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15227 return CreateSignatureDef(_fbb, _o, _rehasher);
15228}
15229
15230inline flatbuffers::Offset<SignatureDef> CreateSignatureDef(flatbuffers::FlatBufferBuilder &_fbb, const SignatureDefT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15231 (void)_rehasher;
15232 (void)_o;
15233 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SignatureDefT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15234 auto _inputs = _o->inputs.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::TensorMap>> (_o->inputs.size(), [](size_t i, _VectorArgs *__va) { return CreateTensorMap(*__va->__fbb, __va->__o->inputs[i].get(), __va->__rehasher); }, &_va ) : 0;
15235 auto _outputs = _o->outputs.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::TensorMap>> (_o->outputs.size(), [](size_t i, _VectorArgs *__va) { return CreateTensorMap(*__va->__fbb, __va->__o->outputs[i].get(), __va->__rehasher); }, &_va ) : 0;
15236 auto _method_name = _o->method_name.empty() ? 0 : _fbb.CreateString(_o->method_name);
15237 auto _key = _o->key.empty() ? 0 : _fbb.CreateString(_o->key);
15238 return tflite::CreateSignatureDef(
15239 _fbb,
15240 _inputs,
15241 _outputs,
15242 _method_name,
15243 _key);
15244}
15245
15246inline ModelT *Model::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15247 auto _o = new ModelT();
15248 UnPackTo(_o, _resolver);
15249 return _o;
15250}
15251
15252inline void Model::UnPackTo(ModelT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15253 (void)_o;
15254 (void)_resolver;
15255 { auto _e = version(); _o->version = _e; }
15256 { auto _e = operator_codes(); if (_e) { _o->operator_codes.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->operator_codes[_i] = std::unique_ptr<tflite::OperatorCodeT>(_e->Get(_i)->UnPack(_resolver)); } } }
15257 { auto _e = subgraphs(); if (_e) { _o->subgraphs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->subgraphs[_i] = std::unique_ptr<tflite::SubGraphT>(_e->Get(_i)->UnPack(_resolver)); } } }
15258 { auto _e = description(); if (_e) _o->description = _e->str(); }
15259 { auto _e = buffers(); if (_e) { _o->buffers.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->buffers[_i] = std::unique_ptr<tflite::BufferT>(_e->Get(_i)->UnPack(_resolver)); } } }
15260 { auto _e = metadata_buffer(); if (_e) { _o->metadata_buffer.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->metadata_buffer[_i] = _e->Get(_i); } } }
15261 { auto _e = metadata(); if (_e) { _o->metadata.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->metadata[_i] = std::unique_ptr<tflite::MetadataT>(_e->Get(_i)->UnPack(_resolver)); } } }
15262 { auto _e = signature_defs(); if (_e) { _o->signature_defs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->signature_defs[_i] = std::unique_ptr<tflite::SignatureDefT>(_e->Get(_i)->UnPack(_resolver)); } } }
15263}
15264
15265inline flatbuffers::Offset<Model> Model::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ModelT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15266 return CreateModel(_fbb, _o, _rehasher);
15267}
15268
15269inline flatbuffers::Offset<Model> CreateModel(flatbuffers::FlatBufferBuilder &_fbb, const ModelT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15270 (void)_rehasher;
15271 (void)_o;
15272 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ModelT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15273 auto _version = _o->version;
15274 auto _operator_codes = _o->operator_codes.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::OperatorCode>> (_o->operator_codes.size(), [](size_t i, _VectorArgs *__va) { return CreateOperatorCode(*__va->__fbb, __va->__o->operator_codes[i].get(), __va->__rehasher); }, &_va ) : 0;
15275 auto _subgraphs = _o->subgraphs.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::SubGraph>> (_o->subgraphs.size(), [](size_t i, _VectorArgs *__va) { return CreateSubGraph(*__va->__fbb, __va->__o->subgraphs[i].get(), __va->__rehasher); }, &_va ) : 0;
15276 auto _description = _o->description.empty() ? 0 : _fbb.CreateString(_o->description);
15277 auto _buffers = _o->buffers.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::Buffer>> (_o->buffers.size(), [](size_t i, _VectorArgs *__va) { return CreateBuffer(*__va->__fbb, __va->__o->buffers[i].get(), __va->__rehasher); }, &_va ) : 0;
15278 auto _metadata_buffer = _o->metadata_buffer.size() ? _fbb.CreateVector(_o->metadata_buffer) : 0;
15279 auto _metadata = _o->metadata.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::Metadata>> (_o->metadata.size(), [](size_t i, _VectorArgs *__va) { return CreateMetadata(*__va->__fbb, __va->__o->metadata[i].get(), __va->__rehasher); }, &_va ) : 0;
15280 auto _signature_defs = _o->signature_defs.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::SignatureDef>> (_o->signature_defs.size(), [](size_t i, _VectorArgs *__va) { return CreateSignatureDef(*__va->__fbb, __va->__o->signature_defs[i].get(), __va->__rehasher); }, &_va ) : 0;
15281 return tflite::CreateModel(
15282 _fbb,
15283 _version,
15284 _operator_codes,
15285 _subgraphs,
15286 _description,
15287 _buffers,
15288 _metadata_buffer,
15289 _metadata,
15290 _signature_defs);
15291}
15292
15293inline bool VerifyQuantizationDetails(flatbuffers::Verifier &verifier, const void *obj, QuantizationDetails type) {
15294 switch (type) {
15295 case QuantizationDetails_NONE: {
15296 return true;
15297 }
15298 case QuantizationDetails_CustomQuantization: {
15299 auto ptr = reinterpret_cast<const tflite::CustomQuantization *>(obj);
15300 return verifier.VerifyTable(ptr);
15301 }
15302 default: return true;
15303 }
15304}
15305
15306inline bool VerifyQuantizationDetailsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
15307 if (!values || !types) return !values && !types;
15308 if (values->size() != types->size()) return false;
15309 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
15310 if (!VerifyQuantizationDetails(
15311 verifier, values->Get(i), types->GetEnum<QuantizationDetails>(i))) {
15312 return false;
15313 }
15314 }
15315 return true;
15316}
15317
15318inline void *QuantizationDetailsUnion::UnPack(const void *obj, QuantizationDetails type, const flatbuffers::resolver_function_t *resolver) {
15319 switch (type) {
15320 case QuantizationDetails_CustomQuantization: {
15321 auto ptr = reinterpret_cast<const tflite::CustomQuantization *>(obj);
15322 return ptr->UnPack(resolver);
15323 }
15324 default: return nullptr;
15325 }
15326}
15327
15328inline flatbuffers::Offset<void> QuantizationDetailsUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
15329 switch (type) {
15330 case QuantizationDetails_CustomQuantization: {
15331 auto ptr = reinterpret_cast<const tflite::CustomQuantizationT *>(value);
15332 return CreateCustomQuantization(_fbb, ptr, _rehasher).Union();
15333 }
15334 default: return 0;
15335 }
15336}
15337
15338inline QuantizationDetailsUnion::QuantizationDetailsUnion(const QuantizationDetailsUnion &u) FLATBUFFERS_NOEXCEPT : type(u.type), value(nullptr) {
15339 switch (type) {
15340 case QuantizationDetails_CustomQuantization: {
15341 value = new tflite::CustomQuantizationT(*reinterpret_cast<tflite::CustomQuantizationT *>(u.value));
15342 break;
15343 }
15344 default:
15345 break;
15346 }
15347}
15348
15349inline void QuantizationDetailsUnion::Reset() {
15350 switch (type) {
15351 case QuantizationDetails_CustomQuantization: {
15352 auto ptr = reinterpret_cast<tflite::CustomQuantizationT *>(value);
15353 delete ptr;
15354 break;
15355 }
15356 default: break;
15357 }
15358 value = nullptr;
15359 type = QuantizationDetails_NONE;
15360}
15361
15362inline bool VerifySparseIndexVector(flatbuffers::Verifier &verifier, const void *obj, SparseIndexVector type) {
15363 switch (type) {
15364 case SparseIndexVector_NONE: {
15365 return true;
15366 }
15367 case SparseIndexVector_Int32Vector: {
15368 auto ptr = reinterpret_cast<const tflite::Int32Vector *>(obj);
15369 return verifier.VerifyTable(ptr);
15370 }
15371 case SparseIndexVector_Uint16Vector: {
15372 auto ptr = reinterpret_cast<const tflite::Uint16Vector *>(obj);
15373 return verifier.VerifyTable(ptr);
15374 }
15375 case SparseIndexVector_Uint8Vector: {
15376 auto ptr = reinterpret_cast<const tflite::Uint8Vector *>(obj);
15377 return verifier.VerifyTable(ptr);
15378 }
15379 default: return true;
15380 }
15381}
15382
15383inline bool VerifySparseIndexVectorVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
15384 if (!values || !types) return !values && !types;
15385 if (values->size() != types->size()) return false;
15386 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
15387 if (!VerifySparseIndexVector(
15388 verifier, values->Get(i), types->GetEnum<SparseIndexVector>(i))) {
15389 return false;
15390 }
15391 }
15392 return true;
15393}
15394
15395inline void *SparseIndexVectorUnion::UnPack(const void *obj, SparseIndexVector type, const flatbuffers::resolver_function_t *resolver) {
15396 switch (type) {
15397 case SparseIndexVector_Int32Vector: {
15398 auto ptr = reinterpret_cast<const tflite::Int32Vector *>(obj);
15399 return ptr->UnPack(resolver);
15400 }
15401 case SparseIndexVector_Uint16Vector: {
15402 auto ptr = reinterpret_cast<const tflite::Uint16Vector *>(obj);
15403 return ptr->UnPack(resolver);
15404 }
15405 case SparseIndexVector_Uint8Vector: {
15406 auto ptr = reinterpret_cast<const tflite::Uint8Vector *>(obj);
15407 return ptr->UnPack(resolver);
15408 }
15409 default: return nullptr;
15410 }
15411}
15412
15413inline flatbuffers::Offset<void> SparseIndexVectorUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
15414 switch (type) {
15415 case SparseIndexVector_Int32Vector: {
15416 auto ptr = reinterpret_cast<const tflite::Int32VectorT *>(value);
15417 return CreateInt32Vector(_fbb, ptr, _rehasher).Union();
15418 }
15419 case SparseIndexVector_Uint16Vector: {
15420 auto ptr = reinterpret_cast<const tflite::Uint16VectorT *>(value);
15421 return CreateUint16Vector(_fbb, ptr, _rehasher).Union();
15422 }
15423 case SparseIndexVector_Uint8Vector: {
15424 auto ptr = reinterpret_cast<const tflite::Uint8VectorT *>(value);
15425 return CreateUint8Vector(_fbb, ptr, _rehasher).Union();
15426 }
15427 default: return 0;
15428 }
15429}
15430
15431inline SparseIndexVectorUnion::SparseIndexVectorUnion(const SparseIndexVectorUnion &u) FLATBUFFERS_NOEXCEPT : type(u.type), value(nullptr) {
15432 switch (type) {
15433 case SparseIndexVector_Int32Vector: {
15434 value = new tflite::Int32VectorT(*reinterpret_cast<tflite::Int32VectorT *>(u.value));
15435 break;
15436 }
15437 case SparseIndexVector_Uint16Vector: {
15438 value = new tflite::Uint16VectorT(*reinterpret_cast<tflite::Uint16VectorT *>(u.value));
15439 break;
15440 }
15441 case SparseIndexVector_Uint8Vector: {
15442 value = new tflite::Uint8VectorT(*reinterpret_cast<tflite::Uint8VectorT *>(u.value));
15443 break;
15444 }
15445 default:
15446 break;
15447 }
15448}
15449
15450inline void SparseIndexVectorUnion::Reset() {
15451 switch (type) {
15452 case SparseIndexVector_Int32Vector: {
15453 auto ptr = reinterpret_cast<tflite::Int32VectorT *>(value);
15454 delete ptr;
15455 break;
15456 }
15457 case SparseIndexVector_Uint16Vector: {
15458 auto ptr = reinterpret_cast<tflite::Uint16VectorT *>(value);
15459 delete ptr;
15460 break;
15461 }
15462 case SparseIndexVector_Uint8Vector: {
15463 auto ptr = reinterpret_cast<tflite::Uint8VectorT *>(value);
15464 delete ptr;
15465 break;
15466 }
15467 default: break;
15468 }
15469 value = nullptr;
15470 type = SparseIndexVector_NONE;
15471}
15472
15473inline bool VerifyBuiltinOptions(flatbuffers::Verifier &verifier, const void *obj, BuiltinOptions type) {
15474 switch (type) {
15475 case BuiltinOptions_NONE: {
15476 return true;
15477 }
15478 case BuiltinOptions_Conv2DOptions: {
15479 auto ptr = reinterpret_cast<const tflite::Conv2DOptions *>(obj);
15480 return verifier.VerifyTable(ptr);
15481 }
15482 case BuiltinOptions_DepthwiseConv2DOptions: {
15483 auto ptr = reinterpret_cast<const tflite::DepthwiseConv2DOptions *>(obj);
15484 return verifier.VerifyTable(ptr);
15485 }
15486 case BuiltinOptions_ConcatEmbeddingsOptions: {
15487 auto ptr = reinterpret_cast<const tflite::ConcatEmbeddingsOptions *>(obj);
15488 return verifier.VerifyTable(ptr);
15489 }
15490 case BuiltinOptions_LSHProjectionOptions: {
15491 auto ptr = reinterpret_cast<const tflite::LSHProjectionOptions *>(obj);
15492 return verifier.VerifyTable(ptr);
15493 }
15494 case BuiltinOptions_Pool2DOptions: {
15495 auto ptr = reinterpret_cast<const tflite::Pool2DOptions *>(obj);
15496 return verifier.VerifyTable(ptr);
15497 }
15498 case BuiltinOptions_SVDFOptions: {
15499 auto ptr = reinterpret_cast<const tflite::SVDFOptions *>(obj);
15500 return verifier.VerifyTable(ptr);
15501 }
15502 case BuiltinOptions_RNNOptions: {
15503 auto ptr = reinterpret_cast<const tflite::RNNOptions *>(obj);
15504 return verifier.VerifyTable(ptr);
15505 }
15506 case BuiltinOptions_FullyConnectedOptions: {
15507 auto ptr = reinterpret_cast<const tflite::FullyConnectedOptions *>(obj);
15508 return verifier.VerifyTable(ptr);
15509 }
15510 case BuiltinOptions_SoftmaxOptions: {
15511 auto ptr = reinterpret_cast<const tflite::SoftmaxOptions *>(obj);
15512 return verifier.VerifyTable(ptr);
15513 }
15514 case BuiltinOptions_ConcatenationOptions: {
15515 auto ptr = reinterpret_cast<const tflite::ConcatenationOptions *>(obj);
15516 return verifier.VerifyTable(ptr);
15517 }
15518 case BuiltinOptions_AddOptions: {
15519 auto ptr = reinterpret_cast<const tflite::AddOptions *>(obj);
15520 return verifier.VerifyTable(ptr);
15521 }
15522 case BuiltinOptions_L2NormOptions: {
15523 auto ptr = reinterpret_cast<const tflite::L2NormOptions *>(obj);
15524 return verifier.VerifyTable(ptr);
15525 }
15526 case BuiltinOptions_LocalResponseNormalizationOptions: {
15527 auto ptr = reinterpret_cast<const tflite::LocalResponseNormalizationOptions *>(obj);
15528 return verifier.VerifyTable(ptr);
15529 }
15530 case BuiltinOptions_LSTMOptions: {
15531 auto ptr = reinterpret_cast<const tflite::LSTMOptions *>(obj);
15532 return verifier.VerifyTable(ptr);
15533 }
15534 case BuiltinOptions_ResizeBilinearOptions: {
15535 auto ptr = reinterpret_cast<const tflite::ResizeBilinearOptions *>(obj);
15536 return verifier.VerifyTable(ptr);
15537 }
15538 case BuiltinOptions_CallOptions: {
15539 auto ptr = reinterpret_cast<const tflite::CallOptions *>(obj);
15540 return verifier.VerifyTable(ptr);
15541 }
15542 case BuiltinOptions_ReshapeOptions: {
15543 auto ptr = reinterpret_cast<const tflite::ReshapeOptions *>(obj);
15544 return verifier.VerifyTable(ptr);
15545 }
15546 case BuiltinOptions_SkipGramOptions: {
15547 auto ptr = reinterpret_cast<const tflite::SkipGramOptions *>(obj);
15548 return verifier.VerifyTable(ptr);
15549 }
15550 case BuiltinOptions_SpaceToDepthOptions: {
15551 auto ptr = reinterpret_cast<const tflite::SpaceToDepthOptions *>(obj);
15552 return verifier.VerifyTable(ptr);
15553 }
15554 case BuiltinOptions_EmbeddingLookupSparseOptions: {
15555 auto ptr = reinterpret_cast<const tflite::EmbeddingLookupSparseOptions *>(obj);
15556 return verifier.VerifyTable(ptr);
15557 }
15558 case BuiltinOptions_MulOptions: {
15559 auto ptr = reinterpret_cast<const tflite::MulOptions *>(obj);
15560 return verifier.VerifyTable(ptr);
15561 }
15562 case BuiltinOptions_PadOptions: {
15563 auto ptr = reinterpret_cast<const tflite::PadOptions *>(obj);
15564 return verifier.VerifyTable(ptr);
15565 }
15566 case BuiltinOptions_GatherOptions: {
15567 auto ptr = reinterpret_cast<const tflite::GatherOptions *>(obj);
15568 return verifier.VerifyTable(ptr);
15569 }
15570 case BuiltinOptions_BatchToSpaceNDOptions: {
15571 auto ptr = reinterpret_cast<const tflite::BatchToSpaceNDOptions *>(obj);
15572 return verifier.VerifyTable(ptr);
15573 }
15574 case BuiltinOptions_SpaceToBatchNDOptions: {
15575 auto ptr = reinterpret_cast<const tflite::SpaceToBatchNDOptions *>(obj);
15576 return verifier.VerifyTable(ptr);
15577 }
15578 case BuiltinOptions_TransposeOptions: {
15579 auto ptr = reinterpret_cast<const tflite::TransposeOptions *>(obj);
15580 return verifier.VerifyTable(ptr);
15581 }
15582 case BuiltinOptions_ReducerOptions: {
15583 auto ptr = reinterpret_cast<const tflite::ReducerOptions *>(obj);
15584 return verifier.VerifyTable(ptr);
15585 }
15586 case BuiltinOptions_SubOptions: {
15587 auto ptr = reinterpret_cast<const tflite::SubOptions *>(obj);
15588 return verifier.VerifyTable(ptr);
15589 }
15590 case BuiltinOptions_DivOptions: {
15591 auto ptr = reinterpret_cast<const tflite::DivOptions *>(obj);
15592 return verifier.VerifyTable(ptr);
15593 }
15594 case BuiltinOptions_SqueezeOptions: {
15595 auto ptr = reinterpret_cast<const tflite::SqueezeOptions *>(obj);
15596 return verifier.VerifyTable(ptr);
15597 }
15598 case BuiltinOptions_SequenceRNNOptions: {
15599 auto ptr = reinterpret_cast<const tflite::SequenceRNNOptions *>(obj);
15600 return verifier.VerifyTable(ptr);
15601 }
15602 case BuiltinOptions_StridedSliceOptions: {
15603 auto ptr = reinterpret_cast<const tflite::StridedSliceOptions *>(obj);
15604 return verifier.VerifyTable(ptr);
15605 }
15606 case BuiltinOptions_ExpOptions: {
15607 auto ptr = reinterpret_cast<const tflite::ExpOptions *>(obj);
15608 return verifier.VerifyTable(ptr);
15609 }
15610 case BuiltinOptions_TopKV2Options: {
15611 auto ptr = reinterpret_cast<const tflite::TopKV2Options *>(obj);
15612 return verifier.VerifyTable(ptr);
15613 }
15614 case BuiltinOptions_SplitOptions: {
15615 auto ptr = reinterpret_cast<const tflite::SplitOptions *>(obj);
15616 return verifier.VerifyTable(ptr);
15617 }
15618 case BuiltinOptions_LogSoftmaxOptions: {
15619 auto ptr = reinterpret_cast<const tflite::LogSoftmaxOptions *>(obj);
15620 return verifier.VerifyTable(ptr);
15621 }
15622 case BuiltinOptions_CastOptions: {
15623 auto ptr = reinterpret_cast<const tflite::CastOptions *>(obj);
15624 return verifier.VerifyTable(ptr);
15625 }
15626 case BuiltinOptions_DequantizeOptions: {
15627 auto ptr = reinterpret_cast<const tflite::DequantizeOptions *>(obj);
15628 return verifier.VerifyTable(ptr);
15629 }
15630 case BuiltinOptions_MaximumMinimumOptions: {
15631 auto ptr = reinterpret_cast<const tflite::MaximumMinimumOptions *>(obj);
15632 return verifier.VerifyTable(ptr);
15633 }
15634 case BuiltinOptions_ArgMaxOptions: {
15635 auto ptr = reinterpret_cast<const tflite::ArgMaxOptions *>(obj);
15636 return verifier.VerifyTable(ptr);
15637 }
15638 case BuiltinOptions_LessOptions: {
15639 auto ptr = reinterpret_cast<const tflite::LessOptions *>(obj);
15640 return verifier.VerifyTable(ptr);
15641 }
15642 case BuiltinOptions_NegOptions: {
15643 auto ptr = reinterpret_cast<const tflite::NegOptions *>(obj);
15644 return verifier.VerifyTable(ptr);
15645 }
15646 case BuiltinOptions_PadV2Options: {
15647 auto ptr = reinterpret_cast<const tflite::PadV2Options *>(obj);
15648 return verifier.VerifyTable(ptr);
15649 }
15650 case BuiltinOptions_GreaterOptions: {
15651 auto ptr = reinterpret_cast<const tflite::GreaterOptions *>(obj);
15652 return verifier.VerifyTable(ptr);
15653 }
15654 case BuiltinOptions_GreaterEqualOptions: {
15655 auto ptr = reinterpret_cast<const tflite::GreaterEqualOptions *>(obj);
15656 return verifier.VerifyTable(ptr);
15657 }
15658 case BuiltinOptions_LessEqualOptions: {
15659 auto ptr = reinterpret_cast<const tflite::LessEqualOptions *>(obj);
15660 return verifier.VerifyTable(ptr);
15661 }
15662 case BuiltinOptions_SelectOptions: {
15663 auto ptr = reinterpret_cast<const tflite::SelectOptions *>(obj);
15664 return verifier.VerifyTable(ptr);
15665 }
15666 case BuiltinOptions_SliceOptions: {
15667 auto ptr = reinterpret_cast<const tflite::SliceOptions *>(obj);
15668 return verifier.VerifyTable(ptr);
15669 }
15670 case BuiltinOptions_TransposeConvOptions: {
15671 auto ptr = reinterpret_cast<const tflite::TransposeConvOptions *>(obj);
15672 return verifier.VerifyTable(ptr);
15673 }
15674 case BuiltinOptions_SparseToDenseOptions: {
15675 auto ptr = reinterpret_cast<const tflite::SparseToDenseOptions *>(obj);
15676 return verifier.VerifyTable(ptr);
15677 }
15678 case BuiltinOptions_TileOptions: {
15679 auto ptr = reinterpret_cast<const tflite::TileOptions *>(obj);
15680 return verifier.VerifyTable(ptr);
15681 }
15682 case BuiltinOptions_ExpandDimsOptions: {
15683 auto ptr = reinterpret_cast<const tflite::ExpandDimsOptions *>(obj);
15684 return verifier.VerifyTable(ptr);
15685 }
15686 case BuiltinOptions_EqualOptions: {
15687 auto ptr = reinterpret_cast<const tflite::EqualOptions *>(obj);
15688 return verifier.VerifyTable(ptr);
15689 }
15690 case BuiltinOptions_NotEqualOptions: {
15691 auto ptr = reinterpret_cast<const tflite::NotEqualOptions *>(obj);
15692 return verifier.VerifyTable(ptr);
15693 }
15694 case BuiltinOptions_ShapeOptions: {
15695 auto ptr = reinterpret_cast<const tflite::ShapeOptions *>(obj);
15696 return verifier.VerifyTable(ptr);
15697 }
15698 case BuiltinOptions_PowOptions: {
15699 auto ptr = reinterpret_cast<const tflite::PowOptions *>(obj);
15700 return verifier.VerifyTable(ptr);
15701 }
15702 case BuiltinOptions_ArgMinOptions: {
15703 auto ptr = reinterpret_cast<const tflite::ArgMinOptions *>(obj);
15704 return verifier.VerifyTable(ptr);
15705 }
15706 case BuiltinOptions_FakeQuantOptions: {
15707 auto ptr = reinterpret_cast<const tflite::FakeQuantOptions *>(obj);
15708 return verifier.VerifyTable(ptr);
15709 }
15710 case BuiltinOptions_PackOptions: {
15711 auto ptr = reinterpret_cast<const tflite::PackOptions *>(obj);
15712 return verifier.VerifyTable(ptr);
15713 }
15714 case BuiltinOptions_LogicalOrOptions: {
15715 auto ptr = reinterpret_cast<const tflite::LogicalOrOptions *>(obj);
15716 return verifier.VerifyTable(ptr);
15717 }
15718 case BuiltinOptions_OneHotOptions: {
15719 auto ptr = reinterpret_cast<const tflite::OneHotOptions *>(obj);
15720 return verifier.VerifyTable(ptr);
15721 }
15722 case BuiltinOptions_LogicalAndOptions: {
15723 auto ptr = reinterpret_cast<const tflite::LogicalAndOptions *>(obj);
15724 return verifier.VerifyTable(ptr);
15725 }
15726 case BuiltinOptions_LogicalNotOptions: {
15727 auto ptr = reinterpret_cast<const tflite::LogicalNotOptions *>(obj);
15728 return verifier.VerifyTable(ptr);
15729 }
15730 case BuiltinOptions_UnpackOptions: {
15731 auto ptr = reinterpret_cast<const tflite::UnpackOptions *>(obj);
15732 return verifier.VerifyTable(ptr);
15733 }
15734 case BuiltinOptions_FloorDivOptions: {
15735 auto ptr = reinterpret_cast<const tflite::FloorDivOptions *>(obj);
15736 return verifier.VerifyTable(ptr);
15737 }
15738 case BuiltinOptions_SquareOptions: {
15739 auto ptr = reinterpret_cast<const tflite::SquareOptions *>(obj);
15740 return verifier.VerifyTable(ptr);
15741 }
15742 case BuiltinOptions_ZerosLikeOptions: {
15743 auto ptr = reinterpret_cast<const tflite::ZerosLikeOptions *>(obj);
15744 return verifier.VerifyTable(ptr);
15745 }
15746 case BuiltinOptions_FillOptions: {
15747 auto ptr = reinterpret_cast<const tflite::FillOptions *>(obj);
15748 return verifier.VerifyTable(ptr);
15749 }
15750 case BuiltinOptions_BidirectionalSequenceLSTMOptions: {
15751 auto ptr = reinterpret_cast<const tflite::BidirectionalSequenceLSTMOptions *>(obj);
15752 return verifier.VerifyTable(ptr);
15753 }
15754 case BuiltinOptions_BidirectionalSequenceRNNOptions: {
15755 auto ptr = reinterpret_cast<const tflite::BidirectionalSequenceRNNOptions *>(obj);
15756 return verifier.VerifyTable(ptr);
15757 }
15758 case BuiltinOptions_UnidirectionalSequenceLSTMOptions: {
15759 auto ptr = reinterpret_cast<const tflite::UnidirectionalSequenceLSTMOptions *>(obj);
15760 return verifier.VerifyTable(ptr);
15761 }
15762 case BuiltinOptions_FloorModOptions: {
15763 auto ptr = reinterpret_cast<const tflite::FloorModOptions *>(obj);
15764 return verifier.VerifyTable(ptr);
15765 }
15766 case BuiltinOptions_RangeOptions: {
15767 auto ptr = reinterpret_cast<const tflite::RangeOptions *>(obj);
15768 return verifier.VerifyTable(ptr);
15769 }
15770 case BuiltinOptions_ResizeNearestNeighborOptions: {
15771 auto ptr = reinterpret_cast<const tflite::ResizeNearestNeighborOptions *>(obj);
15772 return verifier.VerifyTable(ptr);
15773 }
15774 case BuiltinOptions_LeakyReluOptions: {
15775 auto ptr = reinterpret_cast<const tflite::LeakyReluOptions *>(obj);
15776 return verifier.VerifyTable(ptr);
15777 }
15778 case BuiltinOptions_SquaredDifferenceOptions: {
15779 auto ptr = reinterpret_cast<const tflite::SquaredDifferenceOptions *>(obj);
15780 return verifier.VerifyTable(ptr);
15781 }
15782 case BuiltinOptions_MirrorPadOptions: {
15783 auto ptr = reinterpret_cast<const tflite::MirrorPadOptions *>(obj);
15784 return verifier.VerifyTable(ptr);
15785 }
15786 case BuiltinOptions_AbsOptions: {
15787 auto ptr = reinterpret_cast<const tflite::AbsOptions *>(obj);
15788 return verifier.VerifyTable(ptr);
15789 }
15790 case BuiltinOptions_SplitVOptions: {
15791 auto ptr = reinterpret_cast<const tflite::SplitVOptions *>(obj);
15792 return verifier.VerifyTable(ptr);
15793 }
15794 case BuiltinOptions_UniqueOptions: {
15795 auto ptr = reinterpret_cast<const tflite::UniqueOptions *>(obj);
15796 return verifier.VerifyTable(ptr);
15797 }
15798 case BuiltinOptions_ReverseV2Options: {
15799 auto ptr = reinterpret_cast<const tflite::ReverseV2Options *>(obj);
15800 return verifier.VerifyTable(ptr);
15801 }
15802 case BuiltinOptions_AddNOptions: {
15803 auto ptr = reinterpret_cast<const tflite::AddNOptions *>(obj);
15804 return verifier.VerifyTable(ptr);
15805 }
15806 case BuiltinOptions_GatherNdOptions: {
15807 auto ptr = reinterpret_cast<const tflite::GatherNdOptions *>(obj);
15808 return verifier.VerifyTable(ptr);
15809 }
15810 case BuiltinOptions_CosOptions: {
15811 auto ptr = reinterpret_cast<const tflite::CosOptions *>(obj);
15812 return verifier.VerifyTable(ptr);
15813 }
15814 case BuiltinOptions_WhereOptions: {
15815 auto ptr = reinterpret_cast<const tflite::WhereOptions *>(obj);
15816 return verifier.VerifyTable(ptr);
15817 }
15818 case BuiltinOptions_RankOptions: {
15819 auto ptr = reinterpret_cast<const tflite::RankOptions *>(obj);
15820 return verifier.VerifyTable(ptr);
15821 }
15822 case BuiltinOptions_ReverseSequenceOptions: {
15823 auto ptr = reinterpret_cast<const tflite::ReverseSequenceOptions *>(obj);
15824 return verifier.VerifyTable(ptr);
15825 }
15826 case BuiltinOptions_MatrixDiagOptions: {
15827 auto ptr = reinterpret_cast<const tflite::MatrixDiagOptions *>(obj);
15828 return verifier.VerifyTable(ptr);
15829 }
15830 case BuiltinOptions_QuantizeOptions: {
15831 auto ptr = reinterpret_cast<const tflite::QuantizeOptions *>(obj);
15832 return verifier.VerifyTable(ptr);
15833 }
15834 case BuiltinOptions_MatrixSetDiagOptions: {
15835 auto ptr = reinterpret_cast<const tflite::MatrixSetDiagOptions *>(obj);
15836 return verifier.VerifyTable(ptr);
15837 }
15838 case BuiltinOptions_HardSwishOptions: {
15839 auto ptr = reinterpret_cast<const tflite::HardSwishOptions *>(obj);
15840 return verifier.VerifyTable(ptr);
15841 }
15842 case BuiltinOptions_IfOptions: {
15843 auto ptr = reinterpret_cast<const tflite::IfOptions *>(obj);
15844 return verifier.VerifyTable(ptr);
15845 }
15846 case BuiltinOptions_WhileOptions: {
15847 auto ptr = reinterpret_cast<const tflite::WhileOptions *>(obj);
15848 return verifier.VerifyTable(ptr);
15849 }
15850 case BuiltinOptions_DepthToSpaceOptions: {
15851 auto ptr = reinterpret_cast<const tflite::DepthToSpaceOptions *>(obj);
15852 return verifier.VerifyTable(ptr);
15853 }
15854 case BuiltinOptions_NonMaxSuppressionV4Options: {
15855 auto ptr = reinterpret_cast<const tflite::NonMaxSuppressionV4Options *>(obj);
15856 return verifier.VerifyTable(ptr);
15857 }
15858 case BuiltinOptions_NonMaxSuppressionV5Options: {
15859 auto ptr = reinterpret_cast<const tflite::NonMaxSuppressionV5Options *>(obj);
15860 return verifier.VerifyTable(ptr);
15861 }
15862 case BuiltinOptions_ScatterNdOptions: {
15863 auto ptr = reinterpret_cast<const tflite::ScatterNdOptions *>(obj);
15864 return verifier.VerifyTable(ptr);
15865 }
15866 case BuiltinOptions_SelectV2Options: {
15867 auto ptr = reinterpret_cast<const tflite::SelectV2Options *>(obj);
15868 return verifier.VerifyTable(ptr);
15869 }
15870 case BuiltinOptions_DensifyOptions: {
15871 auto ptr = reinterpret_cast<const tflite::DensifyOptions *>(obj);
15872 return verifier.VerifyTable(ptr);
15873 }
15874 case BuiltinOptions_SegmentSumOptions: {
15875 auto ptr = reinterpret_cast<const tflite::SegmentSumOptions *>(obj);
15876 return verifier.VerifyTable(ptr);
15877 }
15878 case BuiltinOptions_BatchMatMulOptions: {
15879 auto ptr = reinterpret_cast<const tflite::BatchMatMulOptions *>(obj);
15880 return verifier.VerifyTable(ptr);
15881 }
15882 case BuiltinOptions_CumsumOptions: {
15883 auto ptr = reinterpret_cast<const tflite::CumsumOptions *>(obj);
15884 return verifier.VerifyTable(ptr);
15885 }
15886 case BuiltinOptions_CallOnceOptions: {
15887 auto ptr = reinterpret_cast<const tflite::CallOnceOptions *>(obj);
15888 return verifier.VerifyTable(ptr);
15889 }
15890 case BuiltinOptions_BroadcastToOptions: {
15891 auto ptr = reinterpret_cast<const tflite::BroadcastToOptions *>(obj);
15892 return verifier.VerifyTable(ptr);
15893 }
15894 case BuiltinOptions_Rfft2dOptions: {
15895 auto ptr = reinterpret_cast<const tflite::Rfft2dOptions *>(obj);
15896 return verifier.VerifyTable(ptr);
15897 }
15898 case BuiltinOptions_Conv3DOptions: {
15899 auto ptr = reinterpret_cast<const tflite::Conv3DOptions *>(obj);
15900 return verifier.VerifyTable(ptr);
15901 }
15902 case BuiltinOptions_HashtableOptions: {
15903 auto ptr = reinterpret_cast<const tflite::HashtableOptions *>(obj);
15904 return verifier.VerifyTable(ptr);
15905 }
15906 case BuiltinOptions_HashtableFindOptions: {
15907 auto ptr = reinterpret_cast<const tflite::HashtableFindOptions *>(obj);
15908 return verifier.VerifyTable(ptr);
15909 }
15910 case BuiltinOptions_HashtableImportOptions: {
15911 auto ptr = reinterpret_cast<const tflite::HashtableImportOptions *>(obj);
15912 return verifier.VerifyTable(ptr);
15913 }
15914 case BuiltinOptions_HashtableSizeOptions: {
15915 auto ptr = reinterpret_cast<const tflite::HashtableSizeOptions *>(obj);
15916 return verifier.VerifyTable(ptr);
15917 }
15918 default: return true;
15919 }
15920}
15921
15922inline bool VerifyBuiltinOptionsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
15923 if (!values || !types) return !values && !types;
15924 if (values->size() != types->size()) return false;
15925 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
15926 if (!VerifyBuiltinOptions(
15927 verifier, values->Get(i), types->GetEnum<BuiltinOptions>(i))) {
15928 return false;
15929 }
15930 }
15931 return true;
15932}
15933
15934inline void *BuiltinOptionsUnion::UnPack(const void *obj, BuiltinOptions type, const flatbuffers::resolver_function_t *resolver) {
15935 switch (type) {
15936 case BuiltinOptions_Conv2DOptions: {
15937 auto ptr = reinterpret_cast<const tflite::Conv2DOptions *>(obj);
15938 return ptr->UnPack(resolver);
15939 }
15940 case BuiltinOptions_DepthwiseConv2DOptions: {
15941 auto ptr = reinterpret_cast<const tflite::DepthwiseConv2DOptions *>(obj);
15942 return ptr->UnPack(resolver);
15943 }
15944 case BuiltinOptions_ConcatEmbeddingsOptions: {
15945 auto ptr = reinterpret_cast<const tflite::ConcatEmbeddingsOptions *>(obj);
15946 return ptr->UnPack(resolver);
15947 }
15948 case BuiltinOptions_LSHProjectionOptions: {
15949 auto ptr = reinterpret_cast<const tflite::LSHProjectionOptions *>(obj);
15950 return ptr->UnPack(resolver);
15951 }
15952 case BuiltinOptions_Pool2DOptions: {
15953 auto ptr = reinterpret_cast<const tflite::Pool2DOptions *>(obj);
15954 return ptr->UnPack(resolver);
15955 }
15956 case BuiltinOptions_SVDFOptions: {
15957 auto ptr = reinterpret_cast<const tflite::SVDFOptions *>(obj);
15958 return ptr->UnPack(resolver);
15959 }
15960 case BuiltinOptions_RNNOptions: {
15961 auto ptr = reinterpret_cast<const tflite::RNNOptions *>(obj);
15962 return ptr->UnPack(resolver);
15963 }
15964 case BuiltinOptions_FullyConnectedOptions: {
15965 auto ptr = reinterpret_cast<const tflite::FullyConnectedOptions *>(obj);
15966 return ptr->UnPack(resolver);
15967 }
15968 case BuiltinOptions_SoftmaxOptions: {
15969 auto ptr = reinterpret_cast<const tflite::SoftmaxOptions *>(obj);
15970 return ptr->UnPack(resolver);
15971 }
15972 case BuiltinOptions_ConcatenationOptions: {
15973 auto ptr = reinterpret_cast<const tflite::ConcatenationOptions *>(obj);
15974 return ptr->UnPack(resolver);
15975 }
15976 case BuiltinOptions_AddOptions: {
15977 auto ptr = reinterpret_cast<const tflite::AddOptions *>(obj);
15978 return ptr->UnPack(resolver);
15979 }
15980 case BuiltinOptions_L2NormOptions: {
15981 auto ptr = reinterpret_cast<const tflite::L2NormOptions *>(obj);
15982 return ptr->UnPack(resolver);
15983 }
15984 case BuiltinOptions_LocalResponseNormalizationOptions: {
15985 auto ptr = reinterpret_cast<const tflite::LocalResponseNormalizationOptions *>(obj);
15986 return ptr->UnPack(resolver);
15987 }
15988 case BuiltinOptions_LSTMOptions: {
15989 auto ptr = reinterpret_cast<const tflite::LSTMOptions *>(obj);
15990 return ptr->UnPack(resolver);
15991 }
15992 case BuiltinOptions_ResizeBilinearOptions: {
15993 auto ptr = reinterpret_cast<const tflite::ResizeBilinearOptions *>(obj);
15994 return ptr->UnPack(resolver);
15995 }
15996 case BuiltinOptions_CallOptions: {
15997 auto ptr = reinterpret_cast<const tflite::CallOptions *>(obj);
15998 return ptr->UnPack(resolver);
15999 }
16000 case BuiltinOptions_ReshapeOptions: {
16001 auto ptr = reinterpret_cast<const tflite::ReshapeOptions *>(obj);
16002 return ptr->UnPack(resolver);
16003 }
16004 case BuiltinOptions_SkipGramOptions: {
16005 auto ptr = reinterpret_cast<const tflite::SkipGramOptions *>(obj);
16006 return ptr->UnPack(resolver);
16007 }
16008 case BuiltinOptions_SpaceToDepthOptions: {
16009 auto ptr = reinterpret_cast<const tflite::SpaceToDepthOptions *>(obj);
16010 return ptr->UnPack(resolver);
16011 }
16012 case BuiltinOptions_EmbeddingLookupSparseOptions: {
16013 auto ptr = reinterpret_cast<const tflite::EmbeddingLookupSparseOptions *>(obj);
16014 return ptr->UnPack(resolver);
16015 }
16016 case BuiltinOptions_MulOptions: {
16017 auto ptr = reinterpret_cast<const tflite::MulOptions *>(obj);
16018 return ptr->UnPack(resolver);
16019 }
16020 case BuiltinOptions_PadOptions: {
16021 auto ptr = reinterpret_cast<const tflite::PadOptions *>(obj);
16022 return ptr->UnPack(resolver);
16023 }
16024 case BuiltinOptions_GatherOptions: {
16025 auto ptr = reinterpret_cast<const tflite::GatherOptions *>(obj);
16026 return ptr->UnPack(resolver);
16027 }
16028 case BuiltinOptions_BatchToSpaceNDOptions: {
16029 auto ptr = reinterpret_cast<const tflite::BatchToSpaceNDOptions *>(obj);
16030 return ptr->UnPack(resolver);
16031 }
16032 case BuiltinOptions_SpaceToBatchNDOptions: {
16033 auto ptr = reinterpret_cast<const tflite::SpaceToBatchNDOptions *>(obj);
16034 return ptr->UnPack(resolver);
16035 }
16036 case BuiltinOptions_TransposeOptions: {
16037 auto ptr = reinterpret_cast<const tflite::TransposeOptions *>(obj);
16038 return ptr->UnPack(resolver);
16039 }
16040 case BuiltinOptions_ReducerOptions: {
16041 auto ptr = reinterpret_cast<const tflite::ReducerOptions *>(obj);
16042 return ptr->UnPack(resolver);
16043 }
16044 case BuiltinOptions_SubOptions: {
16045 auto ptr = reinterpret_cast<const tflite::SubOptions *>(obj);
16046 return ptr->UnPack(resolver);
16047 }
16048 case BuiltinOptions_DivOptions: {
16049 auto ptr = reinterpret_cast<const tflite::DivOptions *>(obj);
16050 return ptr->UnPack(resolver);
16051 }
16052 case BuiltinOptions_SqueezeOptions: {
16053 auto ptr = reinterpret_cast<const tflite::SqueezeOptions *>(obj);
16054 return ptr->UnPack(resolver);
16055 }
16056 case BuiltinOptions_SequenceRNNOptions: {
16057 auto ptr = reinterpret_cast<const tflite::SequenceRNNOptions *>(obj);
16058 return ptr->UnPack(resolver);
16059 }
16060 case BuiltinOptions_StridedSliceOptions: {
16061 auto ptr = reinterpret_cast<const tflite::StridedSliceOptions *>(obj);
16062 return ptr->UnPack(resolver);
16063 }
16064 case BuiltinOptions_ExpOptions: {
16065 auto ptr = reinterpret_cast<const tflite::ExpOptions *>(obj);
16066 return ptr->UnPack(resolver);
16067 }
16068 case BuiltinOptions_TopKV2Options: {
16069 auto ptr = reinterpret_cast<const tflite::TopKV2Options *>(obj);
16070 return ptr->UnPack(resolver);
16071 }
16072 case BuiltinOptions_SplitOptions: {
16073 auto ptr = reinterpret_cast<const tflite::SplitOptions *>(obj);
16074 return ptr->UnPack(resolver);
16075 }
16076 case BuiltinOptions_LogSoftmaxOptions: {
16077 auto ptr = reinterpret_cast<const tflite::LogSoftmaxOptions *>(obj);
16078 return ptr->UnPack(resolver);
16079 }
16080 case BuiltinOptions_CastOptions: {
16081 auto ptr = reinterpret_cast<const tflite::CastOptions *>(obj);
16082 return ptr->UnPack(resolver);
16083 }
16084 case BuiltinOptions_DequantizeOptions: {
16085 auto ptr = reinterpret_cast<const tflite::DequantizeOptions *>(obj);
16086 return ptr->UnPack(resolver);
16087 }
16088 case BuiltinOptions_MaximumMinimumOptions: {
16089 auto ptr = reinterpret_cast<const tflite::MaximumMinimumOptions *>(obj);
16090 return ptr->UnPack(resolver);
16091 }
16092 case BuiltinOptions_ArgMaxOptions: {
16093 auto ptr = reinterpret_cast<const tflite::ArgMaxOptions *>(obj);
16094 return ptr->UnPack(resolver);
16095 }
16096 case BuiltinOptions_LessOptions: {
16097 auto ptr = reinterpret_cast<const tflite::LessOptions *>(obj);
16098 return ptr->UnPack(resolver);
16099 }
16100 case BuiltinOptions_NegOptions: {
16101 auto ptr = reinterpret_cast<const tflite::NegOptions *>(obj);
16102 return ptr->UnPack(resolver);
16103 }
16104 case BuiltinOptions_PadV2Options: {
16105 auto ptr = reinterpret_cast<const tflite::PadV2Options *>(obj);
16106 return ptr->UnPack(resolver);
16107 }
16108 case BuiltinOptions_GreaterOptions: {
16109 auto ptr = reinterpret_cast<const tflite::GreaterOptions *>(obj);
16110 return ptr->UnPack(resolver);
16111 }
16112 case BuiltinOptions_GreaterEqualOptions: {
16113 auto ptr = reinterpret_cast<const tflite::GreaterEqualOptions *>(obj);
16114 return ptr->UnPack(resolver);
16115 }
16116 case BuiltinOptions_LessEqualOptions: {
16117 auto ptr = reinterpret_cast<const tflite::LessEqualOptions *>(obj);
16118 return ptr->UnPack(resolver);
16119 }
16120 case BuiltinOptions_SelectOptions: {
16121 auto ptr = reinterpret_cast<const tflite::SelectOptions *>(obj);
16122 return ptr->UnPack(resolver);
16123 }
16124 case BuiltinOptions_SliceOptions: {
16125 auto ptr = reinterpret_cast<const tflite::SliceOptions *>(obj);
16126 return ptr->UnPack(resolver);
16127 }
16128 case BuiltinOptions_TransposeConvOptions: {
16129 auto ptr = reinterpret_cast<const tflite::TransposeConvOptions *>(obj);
16130 return ptr->UnPack(resolver);
16131 }
16132 case BuiltinOptions_SparseToDenseOptions: {
16133 auto ptr = reinterpret_cast<const tflite::SparseToDenseOptions *>(obj);
16134 return ptr->UnPack(resolver);
16135 }
16136 case BuiltinOptions_TileOptions: {
16137 auto ptr = reinterpret_cast<const tflite::TileOptions *>(obj);
16138 return ptr->UnPack(resolver);
16139 }
16140 case BuiltinOptions_ExpandDimsOptions: {
16141 auto ptr = reinterpret_cast<const tflite::ExpandDimsOptions *>(obj);
16142 return ptr->UnPack(resolver);
16143 }
16144 case BuiltinOptions_EqualOptions: {
16145 auto ptr = reinterpret_cast<const tflite::EqualOptions *>(obj);
16146 return ptr->UnPack(resolver);
16147 }
16148 case BuiltinOptions_NotEqualOptions: {
16149 auto ptr = reinterpret_cast<const tflite::NotEqualOptions *>(obj);
16150 return ptr->UnPack(resolver);
16151 }
16152 case BuiltinOptions_ShapeOptions: {
16153 auto ptr = reinterpret_cast<const tflite::ShapeOptions *>(obj);
16154 return ptr->UnPack(resolver);
16155 }
16156 case BuiltinOptions_PowOptions: {
16157 auto ptr = reinterpret_cast<const tflite::PowOptions *>(obj);
16158 return ptr->UnPack(resolver);
16159 }
16160 case BuiltinOptions_ArgMinOptions: {
16161 auto ptr = reinterpret_cast<const tflite::ArgMinOptions *>(obj);
16162 return ptr->UnPack(resolver);
16163 }
16164 case BuiltinOptions_FakeQuantOptions: {
16165 auto ptr = reinterpret_cast<const tflite::FakeQuantOptions *>(obj);
16166 return ptr->UnPack(resolver);
16167 }
16168 case BuiltinOptions_PackOptions: {
16169 auto ptr = reinterpret_cast<const tflite::PackOptions *>(obj);
16170 return ptr->UnPack(resolver);
16171 }
16172 case BuiltinOptions_LogicalOrOptions: {
16173 auto ptr = reinterpret_cast<const tflite::LogicalOrOptions *>(obj);
16174 return ptr->UnPack(resolver);
16175 }
16176 case BuiltinOptions_OneHotOptions: {
16177 auto ptr = reinterpret_cast<const tflite::OneHotOptions *>(obj);
16178 return ptr->UnPack(resolver);
16179 }
16180 case BuiltinOptions_LogicalAndOptions: {
16181 auto ptr = reinterpret_cast<const tflite::LogicalAndOptions *>(obj);
16182 return ptr->UnPack(resolver);
16183 }
16184 case BuiltinOptions_LogicalNotOptions: {
16185 auto ptr = reinterpret_cast<const tflite::LogicalNotOptions *>(obj);
16186 return ptr->UnPack(resolver);
16187 }
16188 case BuiltinOptions_UnpackOptions: {
16189 auto ptr = reinterpret_cast<const tflite::UnpackOptions *>(obj);
16190 return ptr->UnPack(resolver);
16191 }
16192 case BuiltinOptions_FloorDivOptions: {
16193 auto ptr = reinterpret_cast<const tflite::FloorDivOptions *>(obj);
16194 return ptr->UnPack(resolver);
16195 }
16196 case BuiltinOptions_SquareOptions: {
16197 auto ptr = reinterpret_cast<const tflite::SquareOptions *>(obj);
16198 return ptr->UnPack(resolver);
16199 }
16200 case BuiltinOptions_ZerosLikeOptions: {
16201 auto ptr = reinterpret_cast<const tflite::ZerosLikeOptions *>(obj);
16202 return ptr->UnPack(resolver);
16203 }
16204 case BuiltinOptions_FillOptions: {
16205 auto ptr = reinterpret_cast<const tflite::FillOptions *>(obj);
16206 return ptr->UnPack(resolver);
16207 }
16208 case BuiltinOptions_BidirectionalSequenceLSTMOptions: {
16209 auto ptr = reinterpret_cast<const tflite::BidirectionalSequenceLSTMOptions *>(obj);
16210 return ptr->UnPack(resolver);
16211 }
16212 case BuiltinOptions_BidirectionalSequenceRNNOptions: {
16213 auto ptr = reinterpret_cast<const tflite::BidirectionalSequenceRNNOptions *>(obj);
16214 return ptr->UnPack(resolver);
16215 }
16216 case BuiltinOptions_UnidirectionalSequenceLSTMOptions: {
16217 auto ptr = reinterpret_cast<const tflite::UnidirectionalSequenceLSTMOptions *>(obj);
16218 return ptr->UnPack(resolver);
16219 }
16220 case BuiltinOptions_FloorModOptions: {
16221 auto ptr = reinterpret_cast<const tflite::FloorModOptions *>(obj);
16222 return ptr->UnPack(resolver);
16223 }
16224 case BuiltinOptions_RangeOptions: {
16225 auto ptr = reinterpret_cast<const tflite::RangeOptions *>(obj);
16226 return ptr->UnPack(resolver);
16227 }
16228 case BuiltinOptions_ResizeNearestNeighborOptions: {
16229 auto ptr = reinterpret_cast<const tflite::ResizeNearestNeighborOptions *>(obj);
16230 return ptr->UnPack(resolver);
16231 }
16232 case BuiltinOptions_LeakyReluOptions: {
16233 auto ptr = reinterpret_cast<const tflite::LeakyReluOptions *>(obj);
16234 return ptr->UnPack(resolver);
16235 }
16236 case BuiltinOptions_SquaredDifferenceOptions: {
16237 auto ptr = reinterpret_cast<const tflite::SquaredDifferenceOptions *>(obj);
16238 return ptr->UnPack(resolver);
16239 }
16240 case BuiltinOptions_MirrorPadOptions: {
16241 auto ptr = reinterpret_cast<const tflite::MirrorPadOptions *>(obj);
16242 return ptr->UnPack(resolver);
16243 }
16244 case BuiltinOptions_AbsOptions: {
16245 auto ptr = reinterpret_cast<const tflite::AbsOptions *>(obj);
16246 return ptr->UnPack(resolver);
16247 }
16248 case BuiltinOptions_SplitVOptions: {
16249 auto ptr = reinterpret_cast<const tflite::SplitVOptions *>(obj);
16250 return ptr->UnPack(resolver);
16251 }
16252 case BuiltinOptions_UniqueOptions: {
16253 auto ptr = reinterpret_cast<const tflite::UniqueOptions *>(obj);
16254 return ptr->UnPack(resolver);
16255 }
16256 case BuiltinOptions_ReverseV2Options: {
16257 auto ptr = reinterpret_cast<const tflite::ReverseV2Options *>(obj);
16258 return ptr->UnPack(resolver);
16259 }
16260 case BuiltinOptions_AddNOptions: {
16261 auto ptr = reinterpret_cast<const tflite::AddNOptions *>(obj);
16262 return ptr->UnPack(resolver);
16263 }
16264 case BuiltinOptions_GatherNdOptions: {
16265 auto ptr = reinterpret_cast<const tflite::GatherNdOptions *>(obj);
16266 return ptr->UnPack(resolver);
16267 }
16268 case BuiltinOptions_CosOptions: {
16269 auto ptr = reinterpret_cast<const tflite::CosOptions *>(obj);
16270 return ptr->UnPack(resolver);
16271 }
16272 case BuiltinOptions_WhereOptions: {
16273 auto ptr = reinterpret_cast<const tflite::WhereOptions *>(obj);
16274 return ptr->UnPack(resolver);
16275 }
16276 case BuiltinOptions_RankOptions: {
16277 auto ptr = reinterpret_cast<const tflite::RankOptions *>(obj);
16278 return ptr->UnPack(resolver);
16279 }
16280 case BuiltinOptions_ReverseSequenceOptions: {
16281 auto ptr = reinterpret_cast<const tflite::ReverseSequenceOptions *>(obj);
16282 return ptr->UnPack(resolver);
16283 }
16284 case BuiltinOptions_MatrixDiagOptions: {
16285 auto ptr = reinterpret_cast<const tflite::MatrixDiagOptions *>(obj);
16286 return ptr->UnPack(resolver);
16287 }
16288 case BuiltinOptions_QuantizeOptions: {
16289 auto ptr = reinterpret_cast<const tflite::QuantizeOptions *>(obj);
16290 return ptr->UnPack(resolver);
16291 }
16292 case BuiltinOptions_MatrixSetDiagOptions: {
16293 auto ptr = reinterpret_cast<const tflite::MatrixSetDiagOptions *>(obj);
16294 return ptr->UnPack(resolver);
16295 }
16296 case BuiltinOptions_HardSwishOptions: {
16297 auto ptr = reinterpret_cast<const tflite::HardSwishOptions *>(obj);
16298 return ptr->UnPack(resolver);
16299 }
16300 case BuiltinOptions_IfOptions: {
16301 auto ptr = reinterpret_cast<const tflite::IfOptions *>(obj);
16302 return ptr->UnPack(resolver);
16303 }
16304 case BuiltinOptions_WhileOptions: {
16305 auto ptr = reinterpret_cast<const tflite::WhileOptions *>(obj);
16306 return ptr->UnPack(resolver);
16307 }
16308 case BuiltinOptions_DepthToSpaceOptions: {
16309 auto ptr = reinterpret_cast<const tflite::DepthToSpaceOptions *>(obj);
16310 return ptr->UnPack(resolver);
16311 }
16312 case BuiltinOptions_NonMaxSuppressionV4Options: {
16313 auto ptr = reinterpret_cast<const tflite::NonMaxSuppressionV4Options *>(obj);
16314 return ptr->UnPack(resolver);
16315 }
16316 case BuiltinOptions_NonMaxSuppressionV5Options: {
16317 auto ptr = reinterpret_cast<const tflite::NonMaxSuppressionV5Options *>(obj);
16318 return ptr->UnPack(resolver);
16319 }
16320 case BuiltinOptions_ScatterNdOptions: {
16321 auto ptr = reinterpret_cast<const tflite::ScatterNdOptions *>(obj);
16322 return ptr->UnPack(resolver);
16323 }
16324 case BuiltinOptions_SelectV2Options: {
16325 auto ptr = reinterpret_cast<const tflite::SelectV2Options *>(obj);
16326 return ptr->UnPack(resolver);
16327 }
16328 case BuiltinOptions_DensifyOptions: {
16329 auto ptr = reinterpret_cast<const tflite::DensifyOptions *>(obj);
16330 return ptr->UnPack(resolver);
16331 }
16332 case BuiltinOptions_SegmentSumOptions: {
16333 auto ptr = reinterpret_cast<const tflite::SegmentSumOptions *>(obj);
16334 return ptr->UnPack(resolver);
16335 }
16336 case BuiltinOptions_BatchMatMulOptions: {
16337 auto ptr = reinterpret_cast<const tflite::BatchMatMulOptions *>(obj);
16338 return ptr->UnPack(resolver);
16339 }
16340 case BuiltinOptions_CumsumOptions: {
16341 auto ptr = reinterpret_cast<const tflite::CumsumOptions *>(obj);
16342 return ptr->UnPack(resolver);
16343 }
16344 case BuiltinOptions_CallOnceOptions: {
16345 auto ptr = reinterpret_cast<const tflite::CallOnceOptions *>(obj);
16346 return ptr->UnPack(resolver);
16347 }
16348 case BuiltinOptions_BroadcastToOptions: {
16349 auto ptr = reinterpret_cast<const tflite::BroadcastToOptions *>(obj);
16350 return ptr->UnPack(resolver);
16351 }
16352 case BuiltinOptions_Rfft2dOptions: {
16353 auto ptr = reinterpret_cast<const tflite::Rfft2dOptions *>(obj);
16354 return ptr->UnPack(resolver);
16355 }
16356 case BuiltinOptions_Conv3DOptions: {
16357 auto ptr = reinterpret_cast<const tflite::Conv3DOptions *>(obj);
16358 return ptr->UnPack(resolver);
16359 }
16360 case BuiltinOptions_HashtableOptions: {
16361 auto ptr = reinterpret_cast<const tflite::HashtableOptions *>(obj);
16362 return ptr->UnPack(resolver);
16363 }
16364 case BuiltinOptions_HashtableFindOptions: {
16365 auto ptr = reinterpret_cast<const tflite::HashtableFindOptions *>(obj);
16366 return ptr->UnPack(resolver);
16367 }
16368 case BuiltinOptions_HashtableImportOptions: {
16369 auto ptr = reinterpret_cast<const tflite::HashtableImportOptions *>(obj);
16370 return ptr->UnPack(resolver);
16371 }
16372 case BuiltinOptions_HashtableSizeOptions: {
16373 auto ptr = reinterpret_cast<const tflite::HashtableSizeOptions *>(obj);
16374 return ptr->UnPack(resolver);
16375 }
16376 default: return nullptr;
16377 }
16378}
16379
16380inline flatbuffers::Offset<void> BuiltinOptionsUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
16381 switch (type) {
16382 case BuiltinOptions_Conv2DOptions: {
16383 auto ptr = reinterpret_cast<const tflite::Conv2DOptionsT *>(value);
16384 return CreateConv2DOptions(_fbb, ptr, _rehasher).Union();
16385 }
16386 case BuiltinOptions_DepthwiseConv2DOptions: {
16387 auto ptr = reinterpret_cast<const tflite::DepthwiseConv2DOptionsT *>(value);
16388 return CreateDepthwiseConv2DOptions(_fbb, ptr, _rehasher).Union();
16389 }
16390 case BuiltinOptions_ConcatEmbeddingsOptions: {
16391 auto ptr = reinterpret_cast<const tflite::ConcatEmbeddingsOptionsT *>(value);
16392 return CreateConcatEmbeddingsOptions(_fbb, ptr, _rehasher).Union();
16393 }
16394 case BuiltinOptions_LSHProjectionOptions: {
16395 auto ptr = reinterpret_cast<const tflite::LSHProjectionOptionsT *>(value);
16396 return CreateLSHProjectionOptions(_fbb, ptr, _rehasher).Union();
16397 }
16398 case BuiltinOptions_Pool2DOptions: {
16399 auto ptr = reinterpret_cast<const tflite::Pool2DOptionsT *>(value);
16400 return CreatePool2DOptions(_fbb, ptr, _rehasher).Union();
16401 }
16402 case BuiltinOptions_SVDFOptions: {
16403 auto ptr = reinterpret_cast<const tflite::SVDFOptionsT *>(value);
16404 return CreateSVDFOptions(_fbb, ptr, _rehasher).Union();
16405 }
16406 case BuiltinOptions_RNNOptions: {
16407 auto ptr = reinterpret_cast<const tflite::RNNOptionsT *>(value);
16408 return CreateRNNOptions(_fbb, ptr, _rehasher).Union();
16409 }
16410 case BuiltinOptions_FullyConnectedOptions: {
16411 auto ptr = reinterpret_cast<const tflite::FullyConnectedOptionsT *>(value);
16412 return CreateFullyConnectedOptions(_fbb, ptr, _rehasher).Union();
16413 }
16414 case BuiltinOptions_SoftmaxOptions: {
16415 auto ptr = reinterpret_cast<const tflite::SoftmaxOptionsT *>(value);
16416 return CreateSoftmaxOptions(_fbb, ptr, _rehasher).Union();
16417 }
16418 case BuiltinOptions_ConcatenationOptions: {
16419 auto ptr = reinterpret_cast<const tflite::ConcatenationOptionsT *>(value);
16420 return CreateConcatenationOptions(_fbb, ptr, _rehasher).Union();
16421 }
16422 case BuiltinOptions_AddOptions: {
16423 auto ptr = reinterpret_cast<const tflite::AddOptionsT *>(value);
16424 return CreateAddOptions(_fbb, ptr, _rehasher).Union();
16425 }
16426 case BuiltinOptions_L2NormOptions: {
16427 auto ptr = reinterpret_cast<const tflite::L2NormOptionsT *>(value);
16428 return CreateL2NormOptions(_fbb, ptr, _rehasher).Union();
16429 }
16430 case BuiltinOptions_LocalResponseNormalizationOptions: {
16431 auto ptr = reinterpret_cast<const tflite::LocalResponseNormalizationOptionsT *>(value);
16432 return CreateLocalResponseNormalizationOptions(_fbb, ptr, _rehasher).Union();
16433 }
16434 case BuiltinOptions_LSTMOptions: {
16435 auto ptr = reinterpret_cast<const tflite::LSTMOptionsT *>(value);
16436 return CreateLSTMOptions(_fbb, ptr, _rehasher).Union();
16437 }
16438 case BuiltinOptions_ResizeBilinearOptions: {
16439 auto ptr = reinterpret_cast<const tflite::ResizeBilinearOptionsT *>(value);
16440 return CreateResizeBilinearOptions(_fbb, ptr, _rehasher).Union();
16441 }
16442 case BuiltinOptions_CallOptions: {
16443 auto ptr = reinterpret_cast<const tflite::CallOptionsT *>(value);
16444 return CreateCallOptions(_fbb, ptr, _rehasher).Union();
16445 }
16446 case BuiltinOptions_ReshapeOptions: {
16447 auto ptr = reinterpret_cast<const tflite::ReshapeOptionsT *>(value);
16448 return CreateReshapeOptions(_fbb, ptr, _rehasher).Union();
16449 }
16450 case BuiltinOptions_SkipGramOptions: {
16451 auto ptr = reinterpret_cast<const tflite::SkipGramOptionsT *>(value);
16452 return CreateSkipGramOptions(_fbb, ptr, _rehasher).Union();
16453 }
16454 case BuiltinOptions_SpaceToDepthOptions: {
16455 auto ptr = reinterpret_cast<const tflite::SpaceToDepthOptionsT *>(value);
16456 return CreateSpaceToDepthOptions(_fbb, ptr, _rehasher).Union();
16457 }
16458 case BuiltinOptions_EmbeddingLookupSparseOptions: {
16459 auto ptr = reinterpret_cast<const tflite::EmbeddingLookupSparseOptionsT *>(value);
16460 return CreateEmbeddingLookupSparseOptions(_fbb, ptr, _rehasher).Union();
16461 }
16462 case BuiltinOptions_MulOptions: {
16463 auto ptr = reinterpret_cast<const tflite::MulOptionsT *>(value);
16464 return CreateMulOptions(_fbb, ptr, _rehasher).Union();
16465 }
16466 case BuiltinOptions_PadOptions: {
16467 auto ptr = reinterpret_cast<const tflite::PadOptionsT *>(value);
16468 return CreatePadOptions(_fbb, ptr, _rehasher).Union();
16469 }
16470 case BuiltinOptions_GatherOptions: {
16471 auto ptr = reinterpret_cast<const tflite::GatherOptionsT *>(value);
16472 return CreateGatherOptions(_fbb, ptr, _rehasher).Union();
16473 }
16474 case BuiltinOptions_BatchToSpaceNDOptions: {
16475 auto ptr = reinterpret_cast<const tflite::BatchToSpaceNDOptionsT *>(value);
16476 return CreateBatchToSpaceNDOptions(_fbb, ptr, _rehasher).Union();
16477 }
16478 case BuiltinOptions_SpaceToBatchNDOptions: {
16479 auto ptr = reinterpret_cast<const tflite::SpaceToBatchNDOptionsT *>(value);
16480 return CreateSpaceToBatchNDOptions(_fbb, ptr, _rehasher).Union();
16481 }
16482 case BuiltinOptions_TransposeOptions: {
16483 auto ptr = reinterpret_cast<const tflite::TransposeOptionsT *>(value);
16484 return CreateTransposeOptions(_fbb, ptr, _rehasher).Union();
16485 }
16486 case BuiltinOptions_ReducerOptions: {
16487 auto ptr = reinterpret_cast<const tflite::ReducerOptionsT *>(value);
16488 return CreateReducerOptions(_fbb, ptr, _rehasher).Union();
16489 }
16490 case BuiltinOptions_SubOptions: {
16491 auto ptr = reinterpret_cast<const tflite::SubOptionsT *>(value);
16492 return CreateSubOptions(_fbb, ptr, _rehasher).Union();
16493 }
16494 case BuiltinOptions_DivOptions: {
16495 auto ptr = reinterpret_cast<const tflite::DivOptionsT *>(value);
16496 return CreateDivOptions(_fbb, ptr, _rehasher).Union();
16497 }
16498 case BuiltinOptions_SqueezeOptions: {
16499 auto ptr = reinterpret_cast<const tflite::SqueezeOptionsT *>(value);
16500 return CreateSqueezeOptions(_fbb, ptr, _rehasher).Union();
16501 }
16502 case BuiltinOptions_SequenceRNNOptions: {
16503 auto ptr = reinterpret_cast<const tflite::SequenceRNNOptionsT *>(value);
16504 return CreateSequenceRNNOptions(_fbb, ptr, _rehasher).Union();
16505 }
16506 case BuiltinOptions_StridedSliceOptions: {
16507 auto ptr = reinterpret_cast<const tflite::StridedSliceOptionsT *>(value);
16508 return CreateStridedSliceOptions(_fbb, ptr, _rehasher).Union();
16509 }
16510 case BuiltinOptions_ExpOptions: {
16511 auto ptr = reinterpret_cast<const tflite::ExpOptionsT *>(value);
16512 return CreateExpOptions(_fbb, ptr, _rehasher).Union();
16513 }
16514 case BuiltinOptions_TopKV2Options: {
16515 auto ptr = reinterpret_cast<const tflite::TopKV2OptionsT *>(value);
16516 return CreateTopKV2Options(_fbb, ptr, _rehasher).Union();
16517 }
16518 case BuiltinOptions_SplitOptions: {
16519 auto ptr = reinterpret_cast<const tflite::SplitOptionsT *>(value);
16520 return CreateSplitOptions(_fbb, ptr, _rehasher).Union();
16521 }
16522 case BuiltinOptions_LogSoftmaxOptions: {
16523 auto ptr = reinterpret_cast<const tflite::LogSoftmaxOptionsT *>(value);
16524 return CreateLogSoftmaxOptions(_fbb, ptr, _rehasher).Union();
16525 }
16526 case BuiltinOptions_CastOptions: {
16527 auto ptr = reinterpret_cast<const tflite::CastOptionsT *>(value);
16528 return CreateCastOptions(_fbb, ptr, _rehasher).Union();
16529 }
16530 case BuiltinOptions_DequantizeOptions: {
16531 auto ptr = reinterpret_cast<const tflite::DequantizeOptionsT *>(value);
16532 return CreateDequantizeOptions(_fbb, ptr, _rehasher).Union();
16533 }
16534 case BuiltinOptions_MaximumMinimumOptions: {
16535 auto ptr = reinterpret_cast<const tflite::MaximumMinimumOptionsT *>(value);
16536 return CreateMaximumMinimumOptions(_fbb, ptr, _rehasher).Union();
16537 }
16538 case BuiltinOptions_ArgMaxOptions: {
16539 auto ptr = reinterpret_cast<const tflite::ArgMaxOptionsT *>(value);
16540 return CreateArgMaxOptions(_fbb, ptr, _rehasher).Union();
16541 }
16542 case BuiltinOptions_LessOptions: {
16543 auto ptr = reinterpret_cast<const tflite::LessOptionsT *>(value);
16544 return CreateLessOptions(_fbb, ptr, _rehasher).Union();
16545 }
16546 case BuiltinOptions_NegOptions: {
16547 auto ptr = reinterpret_cast<const tflite::NegOptionsT *>(value);
16548 return CreateNegOptions(_fbb, ptr, _rehasher).Union();
16549 }
16550 case BuiltinOptions_PadV2Options: {
16551 auto ptr = reinterpret_cast<const tflite::PadV2OptionsT *>(value);
16552 return CreatePadV2Options(_fbb, ptr, _rehasher).Union();
16553 }
16554 case BuiltinOptions_GreaterOptions: {
16555 auto ptr = reinterpret_cast<const tflite::GreaterOptionsT *>(value);
16556 return CreateGreaterOptions(_fbb, ptr, _rehasher).Union();
16557 }
16558 case BuiltinOptions_GreaterEqualOptions: {
16559 auto ptr = reinterpret_cast<const tflite::GreaterEqualOptionsT *>(value);
16560 return CreateGreaterEqualOptions(_fbb, ptr, _rehasher).Union();
16561 }
16562 case BuiltinOptions_LessEqualOptions: {
16563 auto ptr = reinterpret_cast<const tflite::LessEqualOptionsT *>(value);
16564 return CreateLessEqualOptions(_fbb, ptr, _rehasher).Union();
16565 }
16566 case BuiltinOptions_SelectOptions: {
16567 auto ptr = reinterpret_cast<const tflite::SelectOptionsT *>(value);
16568 return CreateSelectOptions(_fbb, ptr, _rehasher).Union();
16569 }
16570 case BuiltinOptions_SliceOptions: {
16571 auto ptr = reinterpret_cast<const tflite::SliceOptionsT *>(value);
16572 return CreateSliceOptions(_fbb, ptr, _rehasher).Union();
16573 }
16574 case BuiltinOptions_TransposeConvOptions: {
16575 auto ptr = reinterpret_cast<const tflite::TransposeConvOptionsT *>(value);
16576 return CreateTransposeConvOptions(_fbb, ptr, _rehasher).Union();
16577 }
16578 case BuiltinOptions_SparseToDenseOptions: {
16579 auto ptr = reinterpret_cast<const tflite::SparseToDenseOptionsT *>(value);
16580 return CreateSparseToDenseOptions(_fbb, ptr, _rehasher).Union();
16581 }
16582 case BuiltinOptions_TileOptions: {
16583 auto ptr = reinterpret_cast<const tflite::TileOptionsT *>(value);
16584 return CreateTileOptions(_fbb, ptr, _rehasher).Union();
16585 }
16586 case BuiltinOptions_ExpandDimsOptions: {
16587 auto ptr = reinterpret_cast<const tflite::ExpandDimsOptionsT *>(value);
16588 return CreateExpandDimsOptions(_fbb, ptr, _rehasher).Union();
16589 }
16590 case BuiltinOptions_EqualOptions: {
16591 auto ptr = reinterpret_cast<const tflite::EqualOptionsT *>(value);
16592 return CreateEqualOptions(_fbb, ptr, _rehasher).Union();
16593 }
16594 case BuiltinOptions_NotEqualOptions: {
16595 auto ptr = reinterpret_cast<const tflite::NotEqualOptionsT *>(value);
16596 return CreateNotEqualOptions(_fbb, ptr, _rehasher).Union();
16597 }
16598 case BuiltinOptions_ShapeOptions: {
16599 auto ptr = reinterpret_cast<const tflite::ShapeOptionsT *>(value);
16600 return CreateShapeOptions(_fbb, ptr, _rehasher).Union();
16601 }
16602 case BuiltinOptions_PowOptions: {
16603 auto ptr = reinterpret_cast<const tflite::PowOptionsT *>(value);
16604 return CreatePowOptions(_fbb, ptr, _rehasher).Union();
16605 }
16606 case BuiltinOptions_ArgMinOptions: {
16607 auto ptr = reinterpret_cast<const tflite::ArgMinOptionsT *>(value);
16608 return CreateArgMinOptions(_fbb, ptr, _rehasher).Union();
16609 }
16610 case BuiltinOptions_FakeQuantOptions: {
16611 auto ptr = reinterpret_cast<const tflite::FakeQuantOptionsT *>(value);
16612 return CreateFakeQuantOptions(_fbb, ptr, _rehasher).Union();
16613 }
16614 case BuiltinOptions_PackOptions: {
16615 auto ptr = reinterpret_cast<const tflite::PackOptionsT *>(value);
16616 return CreatePackOptions(_fbb, ptr, _rehasher).Union();
16617 }
16618 case BuiltinOptions_LogicalOrOptions: {
16619 auto ptr = reinterpret_cast<const tflite::LogicalOrOptionsT *>(value);
16620 return CreateLogicalOrOptions(_fbb, ptr, _rehasher).Union();
16621 }
16622 case BuiltinOptions_OneHotOptions: {
16623 auto ptr = reinterpret_cast<const tflite::OneHotOptionsT *>(value);
16624 return CreateOneHotOptions(_fbb, ptr, _rehasher).Union();
16625 }
16626 case BuiltinOptions_LogicalAndOptions: {
16627 auto ptr = reinterpret_cast<const tflite::LogicalAndOptionsT *>(value);
16628 return CreateLogicalAndOptions(_fbb, ptr, _rehasher).Union();
16629 }
16630 case BuiltinOptions_LogicalNotOptions: {
16631 auto ptr = reinterpret_cast<const tflite::LogicalNotOptionsT *>(value);
16632 return CreateLogicalNotOptions(_fbb, ptr, _rehasher).Union();
16633 }
16634 case BuiltinOptions_UnpackOptions: {
16635 auto ptr = reinterpret_cast<const tflite::UnpackOptionsT *>(value);
16636 return CreateUnpackOptions(_fbb, ptr, _rehasher).Union();
16637 }
16638 case BuiltinOptions_FloorDivOptions: {
16639 auto ptr = reinterpret_cast<const tflite::FloorDivOptionsT *>(value);
16640 return CreateFloorDivOptions(_fbb, ptr, _rehasher).Union();
16641 }
16642 case BuiltinOptions_SquareOptions: {
16643 auto ptr = reinterpret_cast<const tflite::SquareOptionsT *>(value);
16644 return CreateSquareOptions(_fbb, ptr, _rehasher).Union();
16645 }
16646 case BuiltinOptions_ZerosLikeOptions: {
16647 auto ptr = reinterpret_cast<const tflite::ZerosLikeOptionsT *>(value);
16648 return CreateZerosLikeOptions(_fbb, ptr, _rehasher).Union();
16649 }
16650 case BuiltinOptions_FillOptions: {
16651 auto ptr = reinterpret_cast<const tflite::FillOptionsT *>(value);
16652 return CreateFillOptions(_fbb, ptr, _rehasher).Union();
16653 }
16654 case BuiltinOptions_BidirectionalSequenceLSTMOptions: {
16655 auto ptr = reinterpret_cast<const tflite::BidirectionalSequenceLSTMOptionsT *>(value);
16656 return CreateBidirectionalSequenceLSTMOptions(_fbb, ptr, _rehasher).Union();
16657 }
16658 case BuiltinOptions_BidirectionalSequenceRNNOptions: {
16659 auto ptr = reinterpret_cast<const tflite::BidirectionalSequenceRNNOptionsT *>(value);
16660 return CreateBidirectionalSequenceRNNOptions(_fbb, ptr, _rehasher).Union();
16661 }
16662 case BuiltinOptions_UnidirectionalSequenceLSTMOptions: {
16663 auto ptr = reinterpret_cast<const tflite::UnidirectionalSequenceLSTMOptionsT *>(value);
16664 return CreateUnidirectionalSequenceLSTMOptions(_fbb, ptr, _rehasher).Union();
16665 }
16666 case BuiltinOptions_FloorModOptions: {
16667 auto ptr = reinterpret_cast<const tflite::FloorModOptionsT *>(value);
16668 return CreateFloorModOptions(_fbb, ptr, _rehasher).Union();
16669 }
16670 case BuiltinOptions_RangeOptions: {
16671 auto ptr = reinterpret_cast<const tflite::RangeOptionsT *>(value);
16672 return CreateRangeOptions(_fbb, ptr, _rehasher).Union();
16673 }
16674 case BuiltinOptions_ResizeNearestNeighborOptions: {
16675 auto ptr = reinterpret_cast<const tflite::ResizeNearestNeighborOptionsT *>(value);
16676 return CreateResizeNearestNeighborOptions(_fbb, ptr, _rehasher).Union();
16677 }
16678 case BuiltinOptions_LeakyReluOptions: {
16679 auto ptr = reinterpret_cast<const tflite::LeakyReluOptionsT *>(value);
16680 return CreateLeakyReluOptions(_fbb, ptr, _rehasher).Union();
16681 }
16682 case BuiltinOptions_SquaredDifferenceOptions: {
16683 auto ptr = reinterpret_cast<const tflite::SquaredDifferenceOptionsT *>(value);
16684 return CreateSquaredDifferenceOptions(_fbb, ptr, _rehasher).Union();
16685 }
16686 case BuiltinOptions_MirrorPadOptions: {
16687 auto ptr = reinterpret_cast<const tflite::MirrorPadOptionsT *>(value);
16688 return CreateMirrorPadOptions(_fbb, ptr, _rehasher).Union();
16689 }
16690 case BuiltinOptions_AbsOptions: {
16691 auto ptr = reinterpret_cast<const tflite::AbsOptionsT *>(value);
16692 return CreateAbsOptions(_fbb, ptr, _rehasher).Union();
16693 }
16694 case BuiltinOptions_SplitVOptions: {
16695 auto ptr = reinterpret_cast<const tflite::SplitVOptionsT *>(value);
16696 return CreateSplitVOptions(_fbb, ptr, _rehasher).Union();
16697 }
16698 case BuiltinOptions_UniqueOptions: {
16699 auto ptr = reinterpret_cast<const tflite::UniqueOptionsT *>(value);
16700 return CreateUniqueOptions(_fbb, ptr, _rehasher).Union();
16701 }
16702 case BuiltinOptions_ReverseV2Options: {
16703 auto ptr = reinterpret_cast<const tflite::ReverseV2OptionsT *>(value);
16704 return CreateReverseV2Options(_fbb, ptr, _rehasher).Union();
16705 }
16706 case BuiltinOptions_AddNOptions: {
16707 auto ptr = reinterpret_cast<const tflite::AddNOptionsT *>(value);
16708 return CreateAddNOptions(_fbb, ptr, _rehasher).Union();
16709 }
16710 case BuiltinOptions_GatherNdOptions: {
16711 auto ptr = reinterpret_cast<const tflite::GatherNdOptionsT *>(value);
16712 return CreateGatherNdOptions(_fbb, ptr, _rehasher).Union();
16713 }
16714 case BuiltinOptions_CosOptions: {
16715 auto ptr = reinterpret_cast<const tflite::CosOptionsT *>(value);
16716 return CreateCosOptions(_fbb, ptr, _rehasher).Union();
16717 }
16718 case BuiltinOptions_WhereOptions: {
16719 auto ptr = reinterpret_cast<const tflite::WhereOptionsT *>(value);
16720 return CreateWhereOptions(_fbb, ptr, _rehasher).Union();
16721 }
16722 case BuiltinOptions_RankOptions: {
16723 auto ptr = reinterpret_cast<const tflite::RankOptionsT *>(value);
16724 return CreateRankOptions(_fbb, ptr, _rehasher).Union();
16725 }
16726 case BuiltinOptions_ReverseSequenceOptions: {
16727 auto ptr = reinterpret_cast<const tflite::ReverseSequenceOptionsT *>(value);
16728 return CreateReverseSequenceOptions(_fbb, ptr, _rehasher).Union();
16729 }
16730 case BuiltinOptions_MatrixDiagOptions: {
16731 auto ptr = reinterpret_cast<const tflite::MatrixDiagOptionsT *>(value);
16732 return CreateMatrixDiagOptions(_fbb, ptr, _rehasher).Union();
16733 }
16734 case BuiltinOptions_QuantizeOptions: {
16735 auto ptr = reinterpret_cast<const tflite::QuantizeOptionsT *>(value);
16736 return CreateQuantizeOptions(_fbb, ptr, _rehasher).Union();
16737 }
16738 case BuiltinOptions_MatrixSetDiagOptions: {
16739 auto ptr = reinterpret_cast<const tflite::MatrixSetDiagOptionsT *>(value);
16740 return CreateMatrixSetDiagOptions(_fbb, ptr, _rehasher).Union();
16741 }
16742 case BuiltinOptions_HardSwishOptions: {
16743 auto ptr = reinterpret_cast<const tflite::HardSwishOptionsT *>(value);
16744 return CreateHardSwishOptions(_fbb, ptr, _rehasher).Union();
16745 }
16746 case BuiltinOptions_IfOptions: {
16747 auto ptr = reinterpret_cast<const tflite::IfOptionsT *>(value);
16748 return CreateIfOptions(_fbb, ptr, _rehasher).Union();
16749 }
16750 case BuiltinOptions_WhileOptions: {
16751 auto ptr = reinterpret_cast<const tflite::WhileOptionsT *>(value);
16752 return CreateWhileOptions(_fbb, ptr, _rehasher).Union();
16753 }
16754 case BuiltinOptions_DepthToSpaceOptions: {
16755 auto ptr = reinterpret_cast<const tflite::DepthToSpaceOptionsT *>(value);
16756 return CreateDepthToSpaceOptions(_fbb, ptr, _rehasher).Union();
16757 }
16758 case BuiltinOptions_NonMaxSuppressionV4Options: {
16759 auto ptr = reinterpret_cast<const tflite::NonMaxSuppressionV4OptionsT *>(value);
16760 return CreateNonMaxSuppressionV4Options(_fbb, ptr, _rehasher).Union();
16761 }
16762 case BuiltinOptions_NonMaxSuppressionV5Options: {
16763 auto ptr = reinterpret_cast<const tflite::NonMaxSuppressionV5OptionsT *>(value);
16764 return CreateNonMaxSuppressionV5Options(_fbb, ptr, _rehasher).Union();
16765 }
16766 case BuiltinOptions_ScatterNdOptions: {
16767 auto ptr = reinterpret_cast<const tflite::ScatterNdOptionsT *>(value);
16768 return CreateScatterNdOptions(_fbb, ptr, _rehasher).Union();
16769 }
16770 case BuiltinOptions_SelectV2Options: {
16771 auto ptr = reinterpret_cast<const tflite::SelectV2OptionsT *>(value);
16772 return CreateSelectV2Options(_fbb, ptr, _rehasher).Union();
16773 }
16774 case BuiltinOptions_DensifyOptions: {
16775 auto ptr = reinterpret_cast<const tflite::DensifyOptionsT *>(value);
16776 return CreateDensifyOptions(_fbb, ptr, _rehasher).Union();
16777 }
16778 case BuiltinOptions_SegmentSumOptions: {
16779 auto ptr = reinterpret_cast<const tflite::SegmentSumOptionsT *>(value);
16780 return CreateSegmentSumOptions(_fbb, ptr, _rehasher).Union();
16781 }
16782 case BuiltinOptions_BatchMatMulOptions: {
16783 auto ptr = reinterpret_cast<const tflite::BatchMatMulOptionsT *>(value);
16784 return CreateBatchMatMulOptions(_fbb, ptr, _rehasher).Union();
16785 }
16786 case BuiltinOptions_CumsumOptions: {
16787 auto ptr = reinterpret_cast<const tflite::CumsumOptionsT *>(value);
16788 return CreateCumsumOptions(_fbb, ptr, _rehasher).Union();
16789 }
16790 case BuiltinOptions_CallOnceOptions: {
16791 auto ptr = reinterpret_cast<const tflite::CallOnceOptionsT *>(value);
16792 return CreateCallOnceOptions(_fbb, ptr, _rehasher).Union();
16793 }
16794 case BuiltinOptions_BroadcastToOptions: {
16795 auto ptr = reinterpret_cast<const tflite::BroadcastToOptionsT *>(value);
16796 return CreateBroadcastToOptions(_fbb, ptr, _rehasher).Union();
16797 }
16798 case BuiltinOptions_Rfft2dOptions: {
16799 auto ptr = reinterpret_cast<const tflite::Rfft2dOptionsT *>(value);
16800 return CreateRfft2dOptions(_fbb, ptr, _rehasher).Union();
16801 }
16802 case BuiltinOptions_Conv3DOptions: {
16803 auto ptr = reinterpret_cast<const tflite::Conv3DOptionsT *>(value);
16804 return CreateConv3DOptions(_fbb, ptr, _rehasher).Union();
16805 }
16806 case BuiltinOptions_HashtableOptions: {
16807 auto ptr = reinterpret_cast<const tflite::HashtableOptionsT *>(value);
16808 return CreateHashtableOptions(_fbb, ptr, _rehasher).Union();
16809 }
16810 case BuiltinOptions_HashtableFindOptions: {
16811 auto ptr = reinterpret_cast<const tflite::HashtableFindOptionsT *>(value);
16812 return CreateHashtableFindOptions(_fbb, ptr, _rehasher).Union();
16813 }
16814 case BuiltinOptions_HashtableImportOptions: {
16815 auto ptr = reinterpret_cast<const tflite::HashtableImportOptionsT *>(value);
16816 return CreateHashtableImportOptions(_fbb, ptr, _rehasher).Union();
16817 }
16818 case BuiltinOptions_HashtableSizeOptions: {
16819 auto ptr = reinterpret_cast<const tflite::HashtableSizeOptionsT *>(value);
16820 return CreateHashtableSizeOptions(_fbb, ptr, _rehasher).Union();
16821 }
16822 default: return 0;
16823 }
16824}
16825
16826inline BuiltinOptionsUnion::BuiltinOptionsUnion(const BuiltinOptionsUnion &u) FLATBUFFERS_NOEXCEPT : type(u.type), value(nullptr) {
16827 switch (type) {
16828 case BuiltinOptions_Conv2DOptions: {
16829 value = new tflite::Conv2DOptionsT(*reinterpret_cast<tflite::Conv2DOptionsT *>(u.value));
16830 break;
16831 }
16832 case BuiltinOptions_DepthwiseConv2DOptions: {
16833 value = new tflite::DepthwiseConv2DOptionsT(*reinterpret_cast<tflite::DepthwiseConv2DOptionsT *>(u.value));
16834 break;
16835 }
16836 case BuiltinOptions_ConcatEmbeddingsOptions: {
16837 value = new tflite::ConcatEmbeddingsOptionsT(*reinterpret_cast<tflite::ConcatEmbeddingsOptionsT *>(u.value));
16838 break;
16839 }
16840 case BuiltinOptions_LSHProjectionOptions: {
16841 value = new tflite::LSHProjectionOptionsT(*reinterpret_cast<tflite::LSHProjectionOptionsT *>(u.value));
16842 break;
16843 }
16844 case BuiltinOptions_Pool2DOptions: {
16845 value = new tflite::Pool2DOptionsT(*reinterpret_cast<tflite::Pool2DOptionsT *>(u.value));
16846 break;
16847 }
16848 case BuiltinOptions_SVDFOptions: {
16849 value = new tflite::SVDFOptionsT(*reinterpret_cast<tflite::SVDFOptionsT *>(u.value));
16850 break;
16851 }
16852 case BuiltinOptions_RNNOptions: {
16853 value = new tflite::RNNOptionsT(*reinterpret_cast<tflite::RNNOptionsT *>(u.value));
16854 break;
16855 }
16856 case BuiltinOptions_FullyConnectedOptions: {
16857 value = new tflite::FullyConnectedOptionsT(*reinterpret_cast<tflite::FullyConnectedOptionsT *>(u.value));
16858 break;
16859 }
16860 case BuiltinOptions_SoftmaxOptions: {
16861 value = new tflite::SoftmaxOptionsT(*reinterpret_cast<tflite::SoftmaxOptionsT *>(u.value));
16862 break;
16863 }
16864 case BuiltinOptions_ConcatenationOptions: {
16865 value = new tflite::ConcatenationOptionsT(*reinterpret_cast<tflite::ConcatenationOptionsT *>(u.value));
16866 break;
16867 }
16868 case BuiltinOptions_AddOptions: {
16869 value = new tflite::AddOptionsT(*reinterpret_cast<tflite::AddOptionsT *>(u.value));
16870 break;
16871 }
16872 case BuiltinOptions_L2NormOptions: {
16873 value = new tflite::L2NormOptionsT(*reinterpret_cast<tflite::L2NormOptionsT *>(u.value));
16874 break;
16875 }
16876 case BuiltinOptions_LocalResponseNormalizationOptions: {
16877 value = new tflite::LocalResponseNormalizationOptionsT(*reinterpret_cast<tflite::LocalResponseNormalizationOptionsT *>(u.value));
16878 break;
16879 }
16880 case BuiltinOptions_LSTMOptions: {
16881 value = new tflite::LSTMOptionsT(*reinterpret_cast<tflite::LSTMOptionsT *>(u.value));
16882 break;
16883 }
16884 case BuiltinOptions_ResizeBilinearOptions: {
16885 value = new tflite::ResizeBilinearOptionsT(*reinterpret_cast<tflite::ResizeBilinearOptionsT *>(u.value));
16886 break;
16887 }
16888 case BuiltinOptions_CallOptions: {
16889 value = new tflite::CallOptionsT(*reinterpret_cast<tflite::CallOptionsT *>(u.value));
16890 break;
16891 }
16892 case BuiltinOptions_ReshapeOptions: {
16893 value = new tflite::ReshapeOptionsT(*reinterpret_cast<tflite::ReshapeOptionsT *>(u.value));
16894 break;
16895 }
16896 case BuiltinOptions_SkipGramOptions: {
16897 value = new tflite::SkipGramOptionsT(*reinterpret_cast<tflite::SkipGramOptionsT *>(u.value));
16898 break;
16899 }
16900 case BuiltinOptions_SpaceToDepthOptions: {
16901 value = new tflite::SpaceToDepthOptionsT(*reinterpret_cast<tflite::SpaceToDepthOptionsT *>(u.value));
16902 break;
16903 }
16904 case BuiltinOptions_EmbeddingLookupSparseOptions: {
16905 value = new tflite::EmbeddingLookupSparseOptionsT(*reinterpret_cast<tflite::EmbeddingLookupSparseOptionsT *>(u.value));
16906 break;
16907 }
16908 case BuiltinOptions_MulOptions: {
16909 value = new tflite::MulOptionsT(*reinterpret_cast<tflite::MulOptionsT *>(u.value));
16910 break;
16911 }
16912 case BuiltinOptions_PadOptions: {
16913 value = new tflite::PadOptionsT(*reinterpret_cast<tflite::PadOptionsT *>(u.value));
16914 break;
16915 }
16916 case BuiltinOptions_GatherOptions: {
16917 value = new tflite::GatherOptionsT(*reinterpret_cast<tflite::GatherOptionsT *>(u.value));
16918 break;
16919 }
16920 case BuiltinOptions_BatchToSpaceNDOptions: {
16921 value = new tflite::BatchToSpaceNDOptionsT(*reinterpret_cast<tflite::BatchToSpaceNDOptionsT *>(u.value));
16922 break;
16923 }
16924 case BuiltinOptions_SpaceToBatchNDOptions: {
16925 value = new tflite::SpaceToBatchNDOptionsT(*reinterpret_cast<tflite::SpaceToBatchNDOptionsT *>(u.value));
16926 break;
16927 }
16928 case BuiltinOptions_TransposeOptions: {
16929 value = new tflite::TransposeOptionsT(*reinterpret_cast<tflite::TransposeOptionsT *>(u.value));
16930 break;
16931 }
16932 case BuiltinOptions_ReducerOptions: {
16933 value = new tflite::ReducerOptionsT(*reinterpret_cast<tflite::ReducerOptionsT *>(u.value));
16934 break;
16935 }
16936 case BuiltinOptions_SubOptions: {
16937 value = new tflite::SubOptionsT(*reinterpret_cast<tflite::SubOptionsT *>(u.value));
16938 break;
16939 }
16940 case BuiltinOptions_DivOptions: {
16941 value = new tflite::DivOptionsT(*reinterpret_cast<tflite::DivOptionsT *>(u.value));
16942 break;
16943 }
16944 case BuiltinOptions_SqueezeOptions: {
16945 value = new tflite::SqueezeOptionsT(*reinterpret_cast<tflite::SqueezeOptionsT *>(u.value));
16946 break;
16947 }
16948 case BuiltinOptions_SequenceRNNOptions: {
16949 value = new tflite::SequenceRNNOptionsT(*reinterpret_cast<tflite::SequenceRNNOptionsT *>(u.value));
16950 break;
16951 }
16952 case BuiltinOptions_StridedSliceOptions: {
16953 value = new tflite::StridedSliceOptionsT(*reinterpret_cast<tflite::StridedSliceOptionsT *>(u.value));
16954 break;
16955 }
16956 case BuiltinOptions_ExpOptions: {
16957 value = new tflite::ExpOptionsT(*reinterpret_cast<tflite::ExpOptionsT *>(u.value));
16958 break;
16959 }
16960 case BuiltinOptions_TopKV2Options: {
16961 value = new tflite::TopKV2OptionsT(*reinterpret_cast<tflite::TopKV2OptionsT *>(u.value));
16962 break;
16963 }
16964 case BuiltinOptions_SplitOptions: {
16965 value = new tflite::SplitOptionsT(*reinterpret_cast<tflite::SplitOptionsT *>(u.value));
16966 break;
16967 }
16968 case BuiltinOptions_LogSoftmaxOptions: {
16969 value = new tflite::LogSoftmaxOptionsT(*reinterpret_cast<tflite::LogSoftmaxOptionsT *>(u.value));
16970 break;
16971 }
16972 case BuiltinOptions_CastOptions: {
16973 value = new tflite::CastOptionsT(*reinterpret_cast<tflite::CastOptionsT *>(u.value));
16974 break;
16975 }
16976 case BuiltinOptions_DequantizeOptions: {
16977 value = new tflite::DequantizeOptionsT(*reinterpret_cast<tflite::DequantizeOptionsT *>(u.value));
16978 break;
16979 }
16980 case BuiltinOptions_MaximumMinimumOptions: {
16981 value = new tflite::MaximumMinimumOptionsT(*reinterpret_cast<tflite::MaximumMinimumOptionsT *>(u.value));
16982 break;
16983 }
16984 case BuiltinOptions_ArgMaxOptions: {
16985 value = new tflite::ArgMaxOptionsT(*reinterpret_cast<tflite::ArgMaxOptionsT *>(u.value));
16986 break;
16987 }
16988 case BuiltinOptions_LessOptions: {
16989 value = new tflite::LessOptionsT(*reinterpret_cast<tflite::LessOptionsT *>(u.value));
16990 break;
16991 }
16992 case BuiltinOptions_NegOptions: {
16993 value = new tflite::NegOptionsT(*reinterpret_cast<tflite::NegOptionsT *>(u.value));
16994 break;
16995 }
16996 case BuiltinOptions_PadV2Options: {
16997 value = new tflite::PadV2OptionsT(*reinterpret_cast<tflite::PadV2OptionsT *>(u.value));
16998 break;
16999 }
17000 case BuiltinOptions_GreaterOptions: {
17001 value = new tflite::GreaterOptionsT(*reinterpret_cast<tflite::GreaterOptionsT *>(u.value));
17002 break;
17003 }
17004 case BuiltinOptions_GreaterEqualOptions: {
17005 value = new tflite::GreaterEqualOptionsT(*reinterpret_cast<tflite::GreaterEqualOptionsT *>(u.value));
17006 break;
17007 }
17008 case BuiltinOptions_LessEqualOptions: {
17009 value = new tflite::LessEqualOptionsT(*reinterpret_cast<tflite::LessEqualOptionsT *>(u.value));
17010 break;
17011 }
17012 case BuiltinOptions_SelectOptions: {
17013 value = new tflite::SelectOptionsT(*reinterpret_cast<tflite::SelectOptionsT *>(u.value));
17014 break;
17015 }
17016 case BuiltinOptions_SliceOptions: {
17017 value = new tflite::SliceOptionsT(*reinterpret_cast<tflite::SliceOptionsT *>(u.value));
17018 break;
17019 }
17020 case BuiltinOptions_TransposeConvOptions: {
17021 value = new tflite::TransposeConvOptionsT(*reinterpret_cast<tflite::TransposeConvOptionsT *>(u.value));
17022 break;
17023 }
17024 case BuiltinOptions_SparseToDenseOptions: {
17025 value = new tflite::SparseToDenseOptionsT(*reinterpret_cast<tflite::SparseToDenseOptionsT *>(u.value));
17026 break;
17027 }
17028 case BuiltinOptions_TileOptions: {
17029 value = new tflite::TileOptionsT(*reinterpret_cast<tflite::TileOptionsT *>(u.value));
17030 break;
17031 }
17032 case BuiltinOptions_ExpandDimsOptions: {
17033 value = new tflite::ExpandDimsOptionsT(*reinterpret_cast<tflite::ExpandDimsOptionsT *>(u.value));
17034 break;
17035 }
17036 case BuiltinOptions_EqualOptions: {
17037 value = new tflite::EqualOptionsT(*reinterpret_cast<tflite::EqualOptionsT *>(u.value));
17038 break;
17039 }
17040 case BuiltinOptions_NotEqualOptions: {
17041 value = new tflite::NotEqualOptionsT(*reinterpret_cast<tflite::NotEqualOptionsT *>(u.value));
17042 break;
17043 }
17044 case BuiltinOptions_ShapeOptions: {
17045 value = new tflite::ShapeOptionsT(*reinterpret_cast<tflite::ShapeOptionsT *>(u.value));
17046 break;
17047 }
17048 case BuiltinOptions_PowOptions: {
17049 value = new tflite::PowOptionsT(*reinterpret_cast<tflite::PowOptionsT *>(u.value));
17050 break;
17051 }
17052 case BuiltinOptions_ArgMinOptions: {
17053 value = new tflite::ArgMinOptionsT(*reinterpret_cast<tflite::ArgMinOptionsT *>(u.value));
17054 break;
17055 }
17056 case BuiltinOptions_FakeQuantOptions: {
17057 value = new tflite::FakeQuantOptionsT(*reinterpret_cast<tflite::FakeQuantOptionsT *>(u.value));
17058 break;
17059 }
17060 case BuiltinOptions_PackOptions: {
17061 value = new tflite::PackOptionsT(*reinterpret_cast<tflite::PackOptionsT *>(u.value));
17062 break;
17063 }
17064 case BuiltinOptions_LogicalOrOptions: {
17065 value = new tflite::LogicalOrOptionsT(*reinterpret_cast<tflite::LogicalOrOptionsT *>(u.value));
17066 break;
17067 }
17068 case BuiltinOptions_OneHotOptions: {
17069 value = new tflite::OneHotOptionsT(*reinterpret_cast<tflite::OneHotOptionsT *>(u.value));
17070 break;
17071 }
17072 case BuiltinOptions_LogicalAndOptions: {
17073 value = new tflite::LogicalAndOptionsT(*reinterpret_cast<tflite::LogicalAndOptionsT *>(u.value));
17074 break;
17075 }
17076 case BuiltinOptions_LogicalNotOptions: {
17077 value = new tflite::LogicalNotOptionsT(*reinterpret_cast<tflite::LogicalNotOptionsT *>(u.value));
17078 break;
17079 }
17080 case BuiltinOptions_UnpackOptions: {
17081 value = new tflite::UnpackOptionsT(*reinterpret_cast<tflite::UnpackOptionsT *>(u.value));
17082 break;
17083 }
17084 case BuiltinOptions_FloorDivOptions: {
17085 value = new tflite::FloorDivOptionsT(*reinterpret_cast<tflite::FloorDivOptionsT *>(u.value));
17086 break;
17087 }
17088 case BuiltinOptions_SquareOptions: {
17089 value = new tflite::SquareOptionsT(*reinterpret_cast<tflite::SquareOptionsT *>(u.value));
17090 break;
17091 }
17092 case BuiltinOptions_ZerosLikeOptions: {
17093 value = new tflite::ZerosLikeOptionsT(*reinterpret_cast<tflite::ZerosLikeOptionsT *>(u.value));
17094 break;
17095 }
17096 case BuiltinOptions_FillOptions: {
17097 value = new tflite::FillOptionsT(*reinterpret_cast<tflite::FillOptionsT *>(u.value));
17098 break;
17099 }
17100 case BuiltinOptions_BidirectionalSequenceLSTMOptions: {
17101 value = new tflite::BidirectionalSequenceLSTMOptionsT(*reinterpret_cast<tflite::BidirectionalSequenceLSTMOptionsT *>(u.value));
17102 break;
17103 }
17104 case BuiltinOptions_BidirectionalSequenceRNNOptions: {
17105 value = new tflite::BidirectionalSequenceRNNOptionsT(*reinterpret_cast<tflite::BidirectionalSequenceRNNOptionsT *>(u.value));
17106 break;
17107 }
17108 case BuiltinOptions_UnidirectionalSequenceLSTMOptions: {
17109 value = new tflite::UnidirectionalSequenceLSTMOptionsT(*reinterpret_cast<tflite::UnidirectionalSequenceLSTMOptionsT *>(u.value));
17110 break;
17111 }
17112 case BuiltinOptions_FloorModOptions: {
17113 value = new tflite::FloorModOptionsT(*reinterpret_cast<tflite::FloorModOptionsT *>(u.value));
17114 break;
17115 }
17116 case BuiltinOptions_RangeOptions: {
17117 value = new tflite::RangeOptionsT(*reinterpret_cast<tflite::RangeOptionsT *>(u.value));
17118 break;
17119 }
17120 case BuiltinOptions_ResizeNearestNeighborOptions: {
17121 value = new tflite::ResizeNearestNeighborOptionsT(*reinterpret_cast<tflite::ResizeNearestNeighborOptionsT *>(u.value));
17122 break;
17123 }
17124 case BuiltinOptions_LeakyReluOptions: {
17125 value = new tflite::LeakyReluOptionsT(*reinterpret_cast<tflite::LeakyReluOptionsT *>(u.value));
17126 break;
17127 }
17128 case BuiltinOptions_SquaredDifferenceOptions: {
17129 value = new tflite::SquaredDifferenceOptionsT(*reinterpret_cast<tflite::SquaredDifferenceOptionsT *>(u.value));
17130 break;
17131 }
17132 case BuiltinOptions_MirrorPadOptions: {
17133 value = new tflite::MirrorPadOptionsT(*reinterpret_cast<tflite::MirrorPadOptionsT *>(u.value));
17134 break;
17135 }
17136 case BuiltinOptions_AbsOptions: {
17137 value = new tflite::AbsOptionsT(*reinterpret_cast<tflite::AbsOptionsT *>(u.value));
17138 break;
17139 }
17140 case BuiltinOptions_SplitVOptions: {
17141 value = new tflite::SplitVOptionsT(*reinterpret_cast<tflite::SplitVOptionsT *>(u.value));
17142 break;
17143 }
17144 case BuiltinOptions_UniqueOptions: {
17145 value = new tflite::UniqueOptionsT(*reinterpret_cast<tflite::UniqueOptionsT *>(u.value));
17146 break;
17147 }
17148 case BuiltinOptions_ReverseV2Options: {
17149 value = new tflite::ReverseV2OptionsT(*reinterpret_cast<tflite::ReverseV2OptionsT *>(u.value));
17150 break;
17151 }
17152 case BuiltinOptions_AddNOptions: {
17153 value = new tflite::AddNOptionsT(*reinterpret_cast<tflite::AddNOptionsT *>(u.value));
17154 break;
17155 }
17156 case BuiltinOptions_GatherNdOptions: {
17157 value = new tflite::GatherNdOptionsT(*reinterpret_cast<tflite::GatherNdOptionsT *>(u.value));
17158 break;
17159 }
17160 case BuiltinOptions_CosOptions: {
17161 value = new tflite::CosOptionsT(*reinterpret_cast<tflite::CosOptionsT *>(u.value));
17162 break;
17163 }
17164 case BuiltinOptions_WhereOptions: {
17165 value = new tflite::WhereOptionsT(*reinterpret_cast<tflite::WhereOptionsT *>(u.value));
17166 break;
17167 }
17168 case BuiltinOptions_RankOptions: {
17169 value = new tflite::RankOptionsT(*reinterpret_cast<tflite::RankOptionsT *>(u.value));
17170 break;
17171 }
17172 case BuiltinOptions_ReverseSequenceOptions: {
17173 value = new tflite::ReverseSequenceOptionsT(*reinterpret_cast<tflite::ReverseSequenceOptionsT *>(u.value));
17174 break;
17175 }
17176 case BuiltinOptions_MatrixDiagOptions: {
17177 value = new tflite::MatrixDiagOptionsT(*reinterpret_cast<tflite::MatrixDiagOptionsT *>(u.value));
17178 break;
17179 }
17180 case BuiltinOptions_QuantizeOptions: {
17181 value = new tflite::QuantizeOptionsT(*reinterpret_cast<tflite::QuantizeOptionsT *>(u.value));
17182 break;
17183 }
17184 case BuiltinOptions_MatrixSetDiagOptions: {
17185 value = new tflite::MatrixSetDiagOptionsT(*reinterpret_cast<tflite::MatrixSetDiagOptionsT *>(u.value));
17186 break;
17187 }
17188 case BuiltinOptions_HardSwishOptions: {
17189 value = new tflite::HardSwishOptionsT(*reinterpret_cast<tflite::HardSwishOptionsT *>(u.value));
17190 break;
17191 }
17192 case BuiltinOptions_IfOptions: {
17193 value = new tflite::IfOptionsT(*reinterpret_cast<tflite::IfOptionsT *>(u.value));
17194 break;
17195 }
17196 case BuiltinOptions_WhileOptions: {
17197 value = new tflite::WhileOptionsT(*reinterpret_cast<tflite::WhileOptionsT *>(u.value));
17198 break;
17199 }
17200 case BuiltinOptions_DepthToSpaceOptions: {
17201 value = new tflite::DepthToSpaceOptionsT(*reinterpret_cast<tflite::DepthToSpaceOptionsT *>(u.value));
17202 break;
17203 }
17204 case BuiltinOptions_NonMaxSuppressionV4Options: {
17205 value = new tflite::NonMaxSuppressionV4OptionsT(*reinterpret_cast<tflite::NonMaxSuppressionV4OptionsT *>(u.value));
17206 break;
17207 }
17208 case BuiltinOptions_NonMaxSuppressionV5Options: {
17209 value = new tflite::NonMaxSuppressionV5OptionsT(*reinterpret_cast<tflite::NonMaxSuppressionV5OptionsT *>(u.value));
17210 break;
17211 }
17212 case BuiltinOptions_ScatterNdOptions: {
17213 value = new tflite::ScatterNdOptionsT(*reinterpret_cast<tflite::ScatterNdOptionsT *>(u.value));
17214 break;
17215 }
17216 case BuiltinOptions_SelectV2Options: {
17217 value = new tflite::SelectV2OptionsT(*reinterpret_cast<tflite::SelectV2OptionsT *>(u.value));
17218 break;
17219 }
17220 case BuiltinOptions_DensifyOptions: {
17221 value = new tflite::DensifyOptionsT(*reinterpret_cast<tflite::DensifyOptionsT *>(u.value));
17222 break;
17223 }
17224 case BuiltinOptions_SegmentSumOptions: {
17225 value = new tflite::SegmentSumOptionsT(*reinterpret_cast<tflite::SegmentSumOptionsT *>(u.value));
17226 break;
17227 }
17228 case BuiltinOptions_BatchMatMulOptions: {
17229 value = new tflite::BatchMatMulOptionsT(*reinterpret_cast<tflite::BatchMatMulOptionsT *>(u.value));
17230 break;
17231 }
17232 case BuiltinOptions_CumsumOptions: {
17233 value = new tflite::CumsumOptionsT(*reinterpret_cast<tflite::CumsumOptionsT *>(u.value));
17234 break;
17235 }
17236 case BuiltinOptions_CallOnceOptions: {
17237 value = new tflite::CallOnceOptionsT(*reinterpret_cast<tflite::CallOnceOptionsT *>(u.value));
17238 break;
17239 }
17240 case BuiltinOptions_BroadcastToOptions: {
17241 value = new tflite::BroadcastToOptionsT(*reinterpret_cast<tflite::BroadcastToOptionsT *>(u.value));
17242 break;
17243 }
17244 case BuiltinOptions_Rfft2dOptions: {
17245 value = new tflite::Rfft2dOptionsT(*reinterpret_cast<tflite::Rfft2dOptionsT *>(u.value));
17246 break;
17247 }
17248 case BuiltinOptions_Conv3DOptions: {
17249 value = new tflite::Conv3DOptionsT(*reinterpret_cast<tflite::Conv3DOptionsT *>(u.value));
17250 break;
17251 }
17252 case BuiltinOptions_HashtableOptions: {
17253 value = new tflite::HashtableOptionsT(*reinterpret_cast<tflite::HashtableOptionsT *>(u.value));
17254 break;
17255 }
17256 case BuiltinOptions_HashtableFindOptions: {
17257 value = new tflite::HashtableFindOptionsT(*reinterpret_cast<tflite::HashtableFindOptionsT *>(u.value));
17258 break;
17259 }
17260 case BuiltinOptions_HashtableImportOptions: {
17261 value = new tflite::HashtableImportOptionsT(*reinterpret_cast<tflite::HashtableImportOptionsT *>(u.value));
17262 break;
17263 }
17264 case BuiltinOptions_HashtableSizeOptions: {
17265 value = new tflite::HashtableSizeOptionsT(*reinterpret_cast<tflite::HashtableSizeOptionsT *>(u.value));
17266 break;
17267 }
17268 default:
17269 break;
17270 }
17271}
17272
17273inline void BuiltinOptionsUnion::Reset() {
17274 switch (type) {
17275 case BuiltinOptions_Conv2DOptions: {
17276 auto ptr = reinterpret_cast<tflite::Conv2DOptionsT *>(value);
17277 delete ptr;
17278 break;
17279 }
17280 case BuiltinOptions_DepthwiseConv2DOptions: {
17281 auto ptr = reinterpret_cast<tflite::DepthwiseConv2DOptionsT *>(value);
17282 delete ptr;
17283 break;
17284 }
17285 case BuiltinOptions_ConcatEmbeddingsOptions: {
17286 auto ptr = reinterpret_cast<tflite::ConcatEmbeddingsOptionsT *>(value);
17287 delete ptr;
17288 break;
17289 }
17290 case BuiltinOptions_LSHProjectionOptions: {
17291 auto ptr = reinterpret_cast<tflite::LSHProjectionOptionsT *>(value);
17292 delete ptr;
17293 break;
17294 }
17295 case BuiltinOptions_Pool2DOptions: {
17296 auto ptr = reinterpret_cast<tflite::Pool2DOptionsT *>(value);
17297 delete ptr;
17298 break;
17299 }
17300 case BuiltinOptions_SVDFOptions: {
17301 auto ptr = reinterpret_cast<tflite::SVDFOptionsT *>(value);
17302 delete ptr;
17303 break;
17304 }
17305 case BuiltinOptions_RNNOptions: {
17306 auto ptr = reinterpret_cast<tflite::RNNOptionsT *>(value);
17307 delete ptr;
17308 break;
17309 }
17310 case BuiltinOptions_FullyConnectedOptions: {
17311 auto ptr = reinterpret_cast<tflite::FullyConnectedOptionsT *>(value);
17312 delete ptr;
17313 break;
17314 }
17315 case BuiltinOptions_SoftmaxOptions: {
17316 auto ptr = reinterpret_cast<tflite::SoftmaxOptionsT *>(value);
17317 delete ptr;
17318 break;
17319 }
17320 case BuiltinOptions_ConcatenationOptions: {
17321 auto ptr = reinterpret_cast<tflite::ConcatenationOptionsT *>(value);
17322 delete ptr;
17323 break;
17324 }
17325 case BuiltinOptions_AddOptions: {
17326 auto ptr = reinterpret_cast<tflite::AddOptionsT *>(value);
17327 delete ptr;
17328 break;
17329 }
17330 case BuiltinOptions_L2NormOptions: {
17331 auto ptr = reinterpret_cast<tflite::L2NormOptionsT *>(value);
17332 delete ptr;
17333 break;
17334 }
17335 case BuiltinOptions_LocalResponseNormalizationOptions: {
17336 auto ptr = reinterpret_cast<tflite::LocalResponseNormalizationOptionsT *>(value);
17337 delete ptr;
17338 break;
17339 }
17340 case BuiltinOptions_LSTMOptions: {
17341 auto ptr = reinterpret_cast<tflite::LSTMOptionsT *>(value);
17342 delete ptr;
17343 break;
17344 }
17345 case BuiltinOptions_ResizeBilinearOptions: {
17346 auto ptr = reinterpret_cast<tflite::ResizeBilinearOptionsT *>(value);
17347 delete ptr;
17348 break;
17349 }
17350 case BuiltinOptions_CallOptions: {
17351 auto ptr = reinterpret_cast<tflite::CallOptionsT *>(value);
17352 delete ptr;
17353 break;
17354 }
17355 case BuiltinOptions_ReshapeOptions: {
17356 auto ptr = reinterpret_cast<tflite::ReshapeOptionsT *>(value);
17357 delete ptr;
17358 break;
17359 }
17360 case BuiltinOptions_SkipGramOptions: {
17361 auto ptr = reinterpret_cast<tflite::SkipGramOptionsT *>(value);
17362 delete ptr;
17363 break;
17364 }
17365 case BuiltinOptions_SpaceToDepthOptions: {
17366 auto ptr = reinterpret_cast<tflite::SpaceToDepthOptionsT *>(value);
17367 delete ptr;
17368 break;
17369 }
17370 case BuiltinOptions_EmbeddingLookupSparseOptions: {
17371 auto ptr = reinterpret_cast<tflite::EmbeddingLookupSparseOptionsT *>(value);
17372 delete ptr;
17373 break;
17374 }
17375 case BuiltinOptions_MulOptions: {
17376 auto ptr = reinterpret_cast<tflite::MulOptionsT *>(value);
17377 delete ptr;
17378 break;
17379 }
17380 case BuiltinOptions_PadOptions: {
17381 auto ptr = reinterpret_cast<tflite::PadOptionsT *>(value);
17382 delete ptr;
17383 break;
17384 }
17385 case BuiltinOptions_GatherOptions: {
17386 auto ptr = reinterpret_cast<tflite::GatherOptionsT *>(value);
17387 delete ptr;
17388 break;
17389 }
17390 case BuiltinOptions_BatchToSpaceNDOptions: {
17391 auto ptr = reinterpret_cast<tflite::BatchToSpaceNDOptionsT *>(value);
17392 delete ptr;
17393 break;
17394 }
17395 case BuiltinOptions_SpaceToBatchNDOptions: {
17396 auto ptr = reinterpret_cast<tflite::SpaceToBatchNDOptionsT *>(value);
17397 delete ptr;
17398 break;
17399 }
17400 case BuiltinOptions_TransposeOptions: {
17401 auto ptr = reinterpret_cast<tflite::TransposeOptionsT *>(value);
17402 delete ptr;
17403 break;
17404 }
17405 case BuiltinOptions_ReducerOptions: {
17406 auto ptr = reinterpret_cast<tflite::ReducerOptionsT *>(value);
17407 delete ptr;
17408 break;
17409 }
17410 case BuiltinOptions_SubOptions: {
17411 auto ptr = reinterpret_cast<tflite::SubOptionsT *>(value);
17412 delete ptr;
17413 break;
17414 }
17415 case BuiltinOptions_DivOptions: {
17416 auto ptr = reinterpret_cast<tflite::DivOptionsT *>(value);
17417 delete ptr;
17418 break;
17419 }
17420 case BuiltinOptions_SqueezeOptions: {
17421 auto ptr = reinterpret_cast<tflite::SqueezeOptionsT *>(value);
17422 delete ptr;
17423 break;
17424 }
17425 case BuiltinOptions_SequenceRNNOptions: {
17426 auto ptr = reinterpret_cast<tflite::SequenceRNNOptionsT *>(value);
17427 delete ptr;
17428 break;
17429 }
17430 case BuiltinOptions_StridedSliceOptions: {
17431 auto ptr = reinterpret_cast<tflite::StridedSliceOptionsT *>(value);
17432 delete ptr;
17433 break;
17434 }
17435 case BuiltinOptions_ExpOptions: {
17436 auto ptr = reinterpret_cast<tflite::ExpOptionsT *>(value);
17437 delete ptr;
17438 break;
17439 }
17440 case BuiltinOptions_TopKV2Options: {
17441 auto ptr = reinterpret_cast<tflite::TopKV2OptionsT *>(value);
17442 delete ptr;
17443 break;
17444 }
17445 case BuiltinOptions_SplitOptions: {
17446 auto ptr = reinterpret_cast<tflite::SplitOptionsT *>(value);
17447 delete ptr;
17448 break;
17449 }
17450 case BuiltinOptions_LogSoftmaxOptions: {
17451 auto ptr = reinterpret_cast<tflite::LogSoftmaxOptionsT *>(value);
17452 delete ptr;
17453 break;
17454 }
17455 case BuiltinOptions_CastOptions: {
17456 auto ptr = reinterpret_cast<tflite::CastOptionsT *>(value);
17457 delete ptr;
17458 break;
17459 }
17460 case BuiltinOptions_DequantizeOptions: {
17461 auto ptr = reinterpret_cast<tflite::DequantizeOptionsT *>(value);
17462 delete ptr;
17463 break;
17464 }
17465 case BuiltinOptions_MaximumMinimumOptions: {
17466 auto ptr = reinterpret_cast<tflite::MaximumMinimumOptionsT *>(value);
17467 delete ptr;
17468 break;
17469 }
17470 case BuiltinOptions_ArgMaxOptions: {
17471 auto ptr = reinterpret_cast<tflite::ArgMaxOptionsT *>(value);
17472 delete ptr;
17473 break;
17474 }
17475 case BuiltinOptions_LessOptions: {
17476 auto ptr = reinterpret_cast<tflite::LessOptionsT *>(value);
17477 delete ptr;
17478 break;
17479 }
17480 case BuiltinOptions_NegOptions: {
17481 auto ptr = reinterpret_cast<tflite::NegOptionsT *>(value);
17482 delete ptr;
17483 break;
17484 }
17485 case BuiltinOptions_PadV2Options: {
17486 auto ptr = reinterpret_cast<tflite::PadV2OptionsT *>(value);
17487 delete ptr;
17488 break;
17489 }
17490 case BuiltinOptions_GreaterOptions: {
17491 auto ptr = reinterpret_cast<tflite::GreaterOptionsT *>(value);
17492 delete ptr;
17493 break;
17494 }
17495 case BuiltinOptions_GreaterEqualOptions: {
17496 auto ptr = reinterpret_cast<tflite::GreaterEqualOptionsT *>(value);
17497 delete ptr;
17498 break;
17499 }
17500 case BuiltinOptions_LessEqualOptions: {
17501 auto ptr = reinterpret_cast<tflite::LessEqualOptionsT *>(value);
17502 delete ptr;
17503 break;
17504 }
17505 case BuiltinOptions_SelectOptions: {
17506 auto ptr = reinterpret_cast<tflite::SelectOptionsT *>(value);
17507 delete ptr;
17508 break;
17509 }
17510 case BuiltinOptions_SliceOptions: {
17511 auto ptr = reinterpret_cast<tflite::SliceOptionsT *>(value);
17512 delete ptr;
17513 break;
17514 }
17515 case BuiltinOptions_TransposeConvOptions: {
17516 auto ptr = reinterpret_cast<tflite::TransposeConvOptionsT *>(value);
17517 delete ptr;
17518 break;
17519 }
17520 case BuiltinOptions_SparseToDenseOptions: {
17521 auto ptr = reinterpret_cast<tflite::SparseToDenseOptionsT *>(value);
17522 delete ptr;
17523 break;
17524 }
17525 case BuiltinOptions_TileOptions: {
17526 auto ptr = reinterpret_cast<tflite::TileOptionsT *>(value);
17527 delete ptr;
17528 break;
17529 }
17530 case BuiltinOptions_ExpandDimsOptions: {
17531 auto ptr = reinterpret_cast<tflite::ExpandDimsOptionsT *>(value);
17532 delete ptr;
17533 break;
17534 }
17535 case BuiltinOptions_EqualOptions: {
17536 auto ptr = reinterpret_cast<tflite::EqualOptionsT *>(value);
17537 delete ptr;
17538 break;
17539 }
17540 case BuiltinOptions_NotEqualOptions: {
17541 auto ptr = reinterpret_cast<tflite::NotEqualOptionsT *>(value);
17542 delete ptr;
17543 break;
17544 }
17545 case BuiltinOptions_ShapeOptions: {
17546 auto ptr = reinterpret_cast<tflite::ShapeOptionsT *>(value);
17547 delete ptr;
17548 break;
17549 }
17550 case BuiltinOptions_PowOptions: {
17551 auto ptr = reinterpret_cast<tflite::PowOptionsT *>(value);
17552 delete ptr;
17553 break;
17554 }
17555 case BuiltinOptions_ArgMinOptions: {
17556 auto ptr = reinterpret_cast<tflite::ArgMinOptionsT *>(value);
17557 delete ptr;
17558 break;
17559 }
17560 case BuiltinOptions_FakeQuantOptions: {
17561 auto ptr = reinterpret_cast<tflite::FakeQuantOptionsT *>(value);
17562 delete ptr;
17563 break;
17564 }
17565 case BuiltinOptions_PackOptions: {
17566 auto ptr = reinterpret_cast<tflite::PackOptionsT *>(value);
17567 delete ptr;
17568 break;
17569 }
17570 case BuiltinOptions_LogicalOrOptions: {
17571 auto ptr = reinterpret_cast<tflite::LogicalOrOptionsT *>(value);
17572 delete ptr;
17573 break;
17574 }
17575 case BuiltinOptions_OneHotOptions: {
17576 auto ptr = reinterpret_cast<tflite::OneHotOptionsT *>(value);
17577 delete ptr;
17578 break;
17579 }
17580 case BuiltinOptions_LogicalAndOptions: {
17581 auto ptr = reinterpret_cast<tflite::LogicalAndOptionsT *>(value);
17582 delete ptr;
17583 break;
17584 }
17585 case BuiltinOptions_LogicalNotOptions: {
17586 auto ptr = reinterpret_cast<tflite::LogicalNotOptionsT *>(value);
17587 delete ptr;
17588 break;
17589 }
17590 case BuiltinOptions_UnpackOptions: {
17591 auto ptr = reinterpret_cast<tflite::UnpackOptionsT *>(value);
17592 delete ptr;
17593 break;
17594 }
17595 case BuiltinOptions_FloorDivOptions: {
17596 auto ptr = reinterpret_cast<tflite::FloorDivOptionsT *>(value);
17597 delete ptr;
17598 break;
17599 }
17600 case BuiltinOptions_SquareOptions: {
17601 auto ptr = reinterpret_cast<tflite::SquareOptionsT *>(value);
17602 delete ptr;
17603 break;
17604 }
17605 case BuiltinOptions_ZerosLikeOptions: {
17606 auto ptr = reinterpret_cast<tflite::ZerosLikeOptionsT *>(value);
17607 delete ptr;
17608 break;
17609 }
17610 case BuiltinOptions_FillOptions: {
17611 auto ptr = reinterpret_cast<tflite::FillOptionsT *>(value);
17612 delete ptr;
17613 break;
17614 }
17615 case BuiltinOptions_BidirectionalSequenceLSTMOptions: {
17616 auto ptr = reinterpret_cast<tflite::BidirectionalSequenceLSTMOptionsT *>(value);
17617 delete ptr;
17618 break;
17619 }
17620 case BuiltinOptions_BidirectionalSequenceRNNOptions: {
17621 auto ptr = reinterpret_cast<tflite::BidirectionalSequenceRNNOptionsT *>(value);
17622 delete ptr;
17623 break;
17624 }
17625 case BuiltinOptions_UnidirectionalSequenceLSTMOptions: {
17626 auto ptr = reinterpret_cast<tflite::UnidirectionalSequenceLSTMOptionsT *>(value);
17627 delete ptr;
17628 break;
17629 }
17630 case BuiltinOptions_FloorModOptions: {
17631 auto ptr = reinterpret_cast<tflite::FloorModOptionsT *>(value);
17632 delete ptr;
17633 break;
17634 }
17635 case BuiltinOptions_RangeOptions: {
17636 auto ptr = reinterpret_cast<tflite::RangeOptionsT *>(value);
17637 delete ptr;
17638 break;
17639 }
17640 case BuiltinOptions_ResizeNearestNeighborOptions: {
17641 auto ptr = reinterpret_cast<tflite::ResizeNearestNeighborOptionsT *>(value);
17642 delete ptr;
17643 break;
17644 }
17645 case BuiltinOptions_LeakyReluOptions: {
17646 auto ptr = reinterpret_cast<tflite::LeakyReluOptionsT *>(value);
17647 delete ptr;
17648 break;
17649 }
17650 case BuiltinOptions_SquaredDifferenceOptions: {
17651 auto ptr = reinterpret_cast<tflite::SquaredDifferenceOptionsT *>(value);
17652 delete ptr;
17653 break;
17654 }
17655 case BuiltinOptions_MirrorPadOptions: {
17656 auto ptr = reinterpret_cast<tflite::MirrorPadOptionsT *>(value);
17657 delete ptr;
17658 break;
17659 }
17660 case BuiltinOptions_AbsOptions: {
17661 auto ptr = reinterpret_cast<tflite::AbsOptionsT *>(value);
17662 delete ptr;
17663 break;
17664 }
17665 case BuiltinOptions_SplitVOptions: {
17666 auto ptr = reinterpret_cast<tflite::SplitVOptionsT *>(value);
17667 delete ptr;
17668 break;
17669 }
17670 case BuiltinOptions_UniqueOptions: {
17671 auto ptr = reinterpret_cast<tflite::UniqueOptionsT *>(value);
17672 delete ptr;
17673 break;
17674 }
17675 case BuiltinOptions_ReverseV2Options: {
17676 auto ptr = reinterpret_cast<tflite::ReverseV2OptionsT *>(value);
17677 delete ptr;
17678 break;
17679 }
17680 case BuiltinOptions_AddNOptions: {
17681 auto ptr = reinterpret_cast<tflite::AddNOptionsT *>(value);
17682 delete ptr;
17683 break;
17684 }
17685 case BuiltinOptions_GatherNdOptions: {
17686 auto ptr = reinterpret_cast<tflite::GatherNdOptionsT *>(value);
17687 delete ptr;
17688 break;
17689 }
17690 case BuiltinOptions_CosOptions: {
17691 auto ptr = reinterpret_cast<tflite::CosOptionsT *>(value);
17692 delete ptr;
17693 break;
17694 }
17695 case BuiltinOptions_WhereOptions: {
17696 auto ptr = reinterpret_cast<tflite::WhereOptionsT *>(value);
17697 delete ptr;
17698 break;
17699 }
17700 case BuiltinOptions_RankOptions: {
17701 auto ptr = reinterpret_cast<tflite::RankOptionsT *>(value);
17702 delete ptr;
17703 break;
17704 }
17705 case BuiltinOptions_ReverseSequenceOptions: {
17706 auto ptr = reinterpret_cast<tflite::ReverseSequenceOptionsT *>(value);
17707 delete ptr;
17708 break;
17709 }
17710 case BuiltinOptions_MatrixDiagOptions: {
17711 auto ptr = reinterpret_cast<tflite::MatrixDiagOptionsT *>(value);
17712 delete ptr;
17713 break;
17714 }
17715 case BuiltinOptions_QuantizeOptions: {
17716 auto ptr = reinterpret_cast<tflite::QuantizeOptionsT *>(value);
17717 delete ptr;
17718 break;
17719 }
17720 case BuiltinOptions_MatrixSetDiagOptions: {
17721 auto ptr = reinterpret_cast<tflite::MatrixSetDiagOptionsT *>(value);
17722 delete ptr;
17723 break;
17724 }
17725 case BuiltinOptions_HardSwishOptions: {
17726 auto ptr = reinterpret_cast<tflite::HardSwishOptionsT *>(value);
17727 delete ptr;
17728 break;
17729 }
17730 case BuiltinOptions_IfOptions: {
17731 auto ptr = reinterpret_cast<tflite::IfOptionsT *>(value);
17732 delete ptr;
17733 break;
17734 }
17735 case BuiltinOptions_WhileOptions: {
17736 auto ptr = reinterpret_cast<tflite::WhileOptionsT *>(value);
17737 delete ptr;
17738 break;
17739 }
17740 case BuiltinOptions_DepthToSpaceOptions: {
17741 auto ptr = reinterpret_cast<tflite::DepthToSpaceOptionsT *>(value);
17742 delete ptr;
17743 break;
17744 }
17745 case BuiltinOptions_NonMaxSuppressionV4Options: {
17746 auto ptr = reinterpret_cast<tflite::NonMaxSuppressionV4OptionsT *>(value);
17747 delete ptr;
17748 break;
17749 }
17750 case BuiltinOptions_NonMaxSuppressionV5Options: {
17751 auto ptr = reinterpret_cast<tflite::NonMaxSuppressionV5OptionsT *>(value);
17752 delete ptr;
17753 break;
17754 }
17755 case BuiltinOptions_ScatterNdOptions: {
17756 auto ptr = reinterpret_cast<tflite::ScatterNdOptionsT *>(value);
17757 delete ptr;
17758 break;
17759 }
17760 case BuiltinOptions_SelectV2Options: {
17761 auto ptr = reinterpret_cast<tflite::SelectV2OptionsT *>(value);
17762 delete ptr;
17763 break;
17764 }
17765 case BuiltinOptions_DensifyOptions: {
17766 auto ptr = reinterpret_cast<tflite::DensifyOptionsT *>(value);
17767 delete ptr;
17768 break;
17769 }
17770 case BuiltinOptions_SegmentSumOptions: {
17771 auto ptr = reinterpret_cast<tflite::SegmentSumOptionsT *>(value);
17772 delete ptr;
17773 break;
17774 }
17775 case BuiltinOptions_BatchMatMulOptions: {
17776 auto ptr = reinterpret_cast<tflite::BatchMatMulOptionsT *>(value);
17777 delete ptr;
17778 break;
17779 }
17780 case BuiltinOptions_CumsumOptions: {
17781 auto ptr = reinterpret_cast<tflite::CumsumOptionsT *>(value);
17782 delete ptr;
17783 break;
17784 }
17785 case BuiltinOptions_CallOnceOptions: {
17786 auto ptr = reinterpret_cast<tflite::CallOnceOptionsT *>(value);
17787 delete ptr;
17788 break;
17789 }
17790 case BuiltinOptions_BroadcastToOptions: {
17791 auto ptr = reinterpret_cast<tflite::BroadcastToOptionsT *>(value);
17792 delete ptr;
17793 break;
17794 }
17795 case BuiltinOptions_Rfft2dOptions: {
17796 auto ptr = reinterpret_cast<tflite::Rfft2dOptionsT *>(value);
17797 delete ptr;
17798 break;
17799 }
17800 case BuiltinOptions_Conv3DOptions: {
17801 auto ptr = reinterpret_cast<tflite::Conv3DOptionsT *>(value);
17802 delete ptr;
17803 break;
17804 }
17805 case BuiltinOptions_HashtableOptions: {
17806 auto ptr = reinterpret_cast<tflite::HashtableOptionsT *>(value);
17807 delete ptr;
17808 break;
17809 }
17810 case BuiltinOptions_HashtableFindOptions: {
17811 auto ptr = reinterpret_cast<tflite::HashtableFindOptionsT *>(value);
17812 delete ptr;
17813 break;
17814 }
17815 case BuiltinOptions_HashtableImportOptions: {
17816 auto ptr = reinterpret_cast<tflite::HashtableImportOptionsT *>(value);
17817 delete ptr;
17818 break;
17819 }
17820 case BuiltinOptions_HashtableSizeOptions: {
17821 auto ptr = reinterpret_cast<tflite::HashtableSizeOptionsT *>(value);
17822 delete ptr;
17823 break;
17824 }
17825 default: break;
17826 }
17827 value = nullptr;
17828 type = BuiltinOptions_NONE;
17829}
17830
17831inline const tflite::Model *GetModel(const void *buf) {
17832 return flatbuffers::GetRoot<tflite::Model>(buf);
17833}
17834
17835inline const tflite::Model *GetSizePrefixedModel(const void *buf) {
17836 return flatbuffers::GetSizePrefixedRoot<tflite::Model>(buf);
17837}
17838
17839inline const char *ModelIdentifier() {
17840 return "TFL3";
17841}
17842
17843inline bool ModelBufferHasIdentifier(const void *buf) {
17844 return flatbuffers::BufferHasIdentifier(
17845 buf, ModelIdentifier());
17846}
17847
17848inline bool VerifyModelBuffer(
17849 flatbuffers::Verifier &verifier) {
17850 return verifier.VerifyBuffer<tflite::Model>(ModelIdentifier());
17851}
17852
17853inline bool VerifySizePrefixedModelBuffer(
17854 flatbuffers::Verifier &verifier) {
17855 return verifier.VerifySizePrefixedBuffer<tflite::Model>(ModelIdentifier());
17856}
17857
17858inline const char *ModelExtension() {
17859 return "tflite";
17860}
17861
17862inline void FinishModelBuffer(
17863 flatbuffers::FlatBufferBuilder &fbb,
17864 flatbuffers::Offset<tflite::Model> root) {
17865 fbb.Finish(root, ModelIdentifier());
17866}
17867
17868inline void FinishSizePrefixedModelBuffer(
17869 flatbuffers::FlatBufferBuilder &fbb,
17870 flatbuffers::Offset<tflite::Model> root) {
17871 fbb.FinishSizePrefixed(root, ModelIdentifier());
17872}
17873
17874inline std::unique_ptr<tflite::ModelT> UnPackModel(
17875 const void *buf,
17876 const flatbuffers::resolver_function_t *res = nullptr) {
17877 return std::unique_ptr<tflite::ModelT>(GetModel(buf)->UnPack(res));
17878}
17879
17880inline std::unique_ptr<tflite::ModelT> UnPackSizePrefixedModel(
17881 const void *buf,
17882 const flatbuffers::resolver_function_t *res = nullptr) {
17883 return std::unique_ptr<tflite::ModelT>(GetSizePrefixedModel(buf)->UnPack(res));
17884}
17885
17886} // namespace tflite
17887
17888#endif // FLATBUFFERS_GENERATED_SCHEMA_TFLITE_H_
17889